From ebf8d39ceb6c4d63f1202868bb6529b39f9e4201 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Mon, 23 Sep 2024 10:54:42 -0700
Subject: [PATCH 01/99] Some debug configs

---
 .../conf/druid/single-server/micro-quickstart/broker/jvm.config  | 1 +
 .../micro-quickstart/coordinator-overlord/jvm.config             | 1 +
 .../druid/single-server/micro-quickstart/historical/jvm.config   | 1 +
 .../single-server/micro-quickstart/middleManager/jvm.config      | 1 +
 .../conf/druid/single-server/micro-quickstart/router/jvm.config  | 1 +
 5 files changed, 5 insertions(+)

diff --git a/examples/conf/druid/single-server/micro-quickstart/broker/jvm.config b/examples/conf/druid/single-server/micro-quickstart/broker/jvm.config
index 5d666f6db234..53f75be7a646 100644
--- a/examples/conf/druid/single-server/micro-quickstart/broker/jvm.config
+++ b/examples/conf/druid/single-server/micro-quickstart/broker/jvm.config
@@ -7,3 +7,4 @@
 -Dfile.encoding=UTF-8
 -Djava.io.tmpdir=var/tmp
 -Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager
+-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5001
diff --git a/examples/conf/druid/single-server/micro-quickstart/coordinator-overlord/jvm.config b/examples/conf/druid/single-server/micro-quickstart/coordinator-overlord/jvm.config
index aae520d8325f..8cf32760f798 100644
--- a/examples/conf/druid/single-server/micro-quickstart/coordinator-overlord/jvm.config
+++ b/examples/conf/druid/single-server/micro-quickstart/coordinator-overlord/jvm.config
@@ -7,3 +7,4 @@
 -Djava.io.tmpdir=var/tmp
 -Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager
 -Dderby.stream.error.file=var/druid/derby.log
+-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5002
diff --git a/examples/conf/druid/single-server/micro-quickstart/historical/jvm.config b/examples/conf/druid/single-server/micro-quickstart/historical/jvm.config
index 79edb06e2030..d13169a217b3 100644
--- a/examples/conf/druid/single-server/micro-quickstart/historical/jvm.config
+++ b/examples/conf/druid/single-server/micro-quickstart/historical/jvm.config
@@ -7,3 +7,4 @@
 -Dfile.encoding=UTF-8
 -Djava.io.tmpdir=var/tmp
 -Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager
+-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5003
diff --git a/examples/conf/druid/single-server/micro-quickstart/middleManager/jvm.config b/examples/conf/druid/single-server/micro-quickstart/middleManager/jvm.config
index 8a650fb358c9..a24e8037d8e7 100644
--- a/examples/conf/druid/single-server/micro-quickstart/middleManager/jvm.config
+++ b/examples/conf/druid/single-server/micro-quickstart/middleManager/jvm.config
@@ -6,3 +6,4 @@
 -Dfile.encoding=UTF-8
 -Djava.io.tmpdir=var/tmp
 -Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager
+-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5004
diff --git a/examples/conf/druid/single-server/micro-quickstart/router/jvm.config b/examples/conf/druid/single-server/micro-quickstart/router/jvm.config
index b822f4601790..909f7dfe705a 100644
--- a/examples/conf/druid/single-server/micro-quickstart/router/jvm.config
+++ b/examples/conf/druid/single-server/micro-quickstart/router/jvm.config
@@ -7,3 +7,4 @@
 -Dfile.encoding=UTF-8
 -Djava.io.tmpdir=var/tmp
 -Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager
+-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005

From 9d01ab6f79cd51fc90c28132da1cc7e5905a5a31 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Thu, 17 Oct 2024 14:08:33 -0700
Subject: [PATCH 02/99] use postgresql as the default metadata store and set a
 few debug log

---
 .../_common/common.runtime.properties         | 22 +++++++++----------
 .../micro-quickstart/_common/log4j2.xml       |  8 +++----
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties b/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties
index d27c83ca569e..f1845df19b5f 100644
--- a/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties
+++ b/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties
@@ -24,7 +24,7 @@
 # If you specify `druid.extensions.loadList=[]`, Druid won't load any extension from file system.
 # If you don't specify `druid.extensions.loadList`, Druid will load all the extensions under root extension directory.
 # More info: https://druid.apache.org/docs/latest/operations/including-extensions.html
-druid.extensions.loadList=["druid-hdfs-storage", "druid-kafka-indexing-service", "druid-datasketches", "druid-multi-stage-query", "druid-parquet-extensions"]
+druid.extensions.loadList=["postgresql-metadata-storage", "druid-hdfs-storage", "druid-kafka-indexing-service", "druid-datasketches", "druid-multi-stage-query", "druid-parquet-extensions"]
 
 # If you have a different version of Hadoop, place your Hadoop client jar files in your hadoop-dependencies directory
 # and uncomment the line below to point to your directory.
@@ -55,10 +55,10 @@ druid.zk.paths.base=/druid
 #
 
 # For Derby server on your Druid Coordinator (only viable in a cluster with a single Coordinator, no fail-over):
-druid.metadata.storage.type=derby
-druid.metadata.storage.connector.connectURI=jdbc:derby://localhost:1527/var/druid/metadata.db;create=true
-druid.metadata.storage.connector.host=localhost
-druid.metadata.storage.connector.port=1527
+# druid.metadata.storage.type=derby
+# druid.metadata.storage.connector.connectURI=jdbc:derby://localhost:1527/var/druid/metadata.db;create=true
+# druid.metadata.storage.connector.host=localhost
+# druid.metadata.storage.connector.port=1527
 
 # For MySQL (make sure to include the MySQL JDBC driver on the classpath):
 #druid.metadata.storage.type=mysql
@@ -67,10 +67,10 @@ druid.metadata.storage.connector.port=1527
 #druid.metadata.storage.connector.password=...
 
 # For PostgreSQL:
-#druid.metadata.storage.type=postgresql
-#druid.metadata.storage.connector.connectURI=jdbc:postgresql://db.example.com:5432/druid
-#druid.metadata.storage.connector.user=...
-#druid.metadata.storage.connector.password=...
+druid.metadata.storage.type=postgresql
+druid.metadata.storage.connector.connectURI=jdbc:postgresql://localhost:5432/druid
+druid.metadata.storage.connector.user=druid
+druid.metadata.storage.connector.password=druid
 
 #
 # Deep storage
@@ -120,8 +120,8 @@ druid.selectors.coordinator.serviceName=druid/coordinator
 #
 
 druid.monitoring.monitors=["org.apache.druid.java.util.metrics.JvmMonitor", "org.apache.druid.server.metrics.ServiceStatusMonitor"]
-druid.emitter=noop
-druid.emitter.logging.logLevel=info
+druid.emitter=logging
+druid.emitter.logging.logLevel=debug
 
 # Storage type of double columns
 # ommiting this will lead to index double as float at the storage layer
diff --git a/examples/conf/druid/single-server/micro-quickstart/_common/log4j2.xml b/examples/conf/druid/single-server/micro-quickstart/_common/log4j2.xml
index eb24a2a89406..aa4816e5e515 100644
--- a/examples/conf/druid/single-server/micro-quickstart/_common/log4j2.xml
+++ b/examples/conf/druid/single-server/micro-quickstart/_common/log4j2.xml
@@ -53,20 +53,20 @@
     </Root>
 
     <!-- Set level="debug" to see stack traces for query errors -->
-    <Logger name="org.apache.druid.server.QueryResource" level="info" additivity="false">
+    <Logger name="org.apache.druid.server.QueryResource" level="debug" additivity="false">
       <Appender-ref ref="FileAppender"/>
     </Logger>
-    <Logger name="org.apache.druid.server.QueryLifecycle" level="info" additivity="false">
+    <Logger name="org.apache.druid.server.QueryLifecycle" level="debug" additivity="false">
       <Appender-ref ref="FileAppender"/>
     </Logger>
 
     <!-- Set level="debug" or "trace" to see more Coordinator details (segment balancing, load/drop rules, etc) -->
-    <Logger name="org.apache.druid.server.coordinator" level="info" additivity="false">
+    <Logger name="org.apache.druid.server.coordinator" level="debug" additivity="false">
       <Appender-ref ref="FileAppender"/>
     </Logger>
 
     <!-- Set level="debug" to see low-level details about segments and ingestion -->
-    <Logger name="org.apache.druid.segment" level="info" additivity="false">
+    <Logger name="org.apache.druid.segment" level="debug" additivity="false">
       <Appender-ref ref="FileAppender"/>
     </Logger>
 

From 1d325dca4d8f37a811889cb864fdbb9dfc7ac384 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Tue, 29 Oct 2024 12:38:44 -0700
Subject: [PATCH 03/99] Add s3 extension, update local storage directory, use
 emoji in website title

---
 .../micro-quickstart/_common/common.runtime.properties        | 4 ++--
 web-console/unified-console.html                              | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties b/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties
index f1845df19b5f..ad69643b83d9 100644
--- a/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties
+++ b/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties
@@ -24,7 +24,7 @@
 # If you specify `druid.extensions.loadList=[]`, Druid won't load any extension from file system.
 # If you don't specify `druid.extensions.loadList`, Druid will load all the extensions under root extension directory.
 # More info: https://druid.apache.org/docs/latest/operations/including-extensions.html
-druid.extensions.loadList=["postgresql-metadata-storage", "druid-hdfs-storage", "druid-kafka-indexing-service", "druid-datasketches", "druid-multi-stage-query", "druid-parquet-extensions"]
+druid.extensions.loadList=["druid-s3-extensions","postgresql-metadata-storage", "druid-hdfs-storage", "druid-kafka-indexing-service", "druid-datasketches", "druid-multi-stage-query", "druid-parquet-extensions"]
 
 # If you have a different version of Hadoop, place your Hadoop client jar files in your hadoop-dependencies directory
 # and uncomment the line below to point to your directory.
@@ -78,7 +78,7 @@ druid.metadata.storage.connector.password=druid
 
 # For local disk (only viable in a cluster if this is a network mount):
 druid.storage.type=local
-druid.storage.storageDirectory=var/druid/segments
+druid.storage.storageDirectory=/Users/cecemei/codespace/var/druid/segments
 
 # For HDFS:
 #druid.storage.type=hdfs
diff --git a/web-console/unified-console.html b/web-console/unified-console.html
index 330c5ece9d41..bc8471f285db 100644
--- a/web-console/unified-console.html
+++ b/web-console/unified-console.html
@@ -24,7 +24,7 @@
       name="viewport"
       content="width=device-width, user-scalable=no, initial-scale=1, maximum-scale=1, minimum-scale=1"
     />
-    <title>Apache Druid</title>
+    <title>&#9889;Apache Druid</title>
     <meta name="description" content="Apache Druid console" />
     <link rel="shortcut icon" href="favicon.png" />
     <style>

From e2f88eae96af4deb5c04324fbf3600de05a3c462 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Tue, 29 Oct 2024 17:01:08 -0700
Subject: [PATCH 04/99] Update favicon, easier to find the console tab

---
 web-console/favicon.png | Bin 1156 -> 403 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/web-console/favicon.png b/web-console/favicon.png
index 96b9aff6791eb0e7ac3eb34d904a86227f3ec350..c449d4cc189cf2427c452e50446416539e596059 100644
GIT binary patch
literal 403
zcmeAS@N?(olHy`uVBq!ia0vp^9w5xY3?!3`olAj~Yk*IPt9yaZ!xwMS(3xv@uit-q
z@%BTYc-Accl?PVMKX~WC^EbY8Zdp&cc~{RRW}@}QMQd+6ho8NE@50Rog;wcnfCjRc
z1o;IsB)k_;IKRK+&%yUVp>Lipjv*CsZ*T1GYc>#QedxgSnESi;z5jvX$s2nDrHqbW
zQqr$~{!H7gs8}w1?TWdZc6H1Mf7-C>`nxH7tNu*YVh_vxp18nx+BOM=cSml|>RYPh
zU}~MO#Ov}UZ6%+;<hCsWl5ICDjZ(f&uyt6{evP3}!DXjIu6@fdvF2Ne>suGZEs$$!
zTjBqrJL!byOy?gP|I6%Jc+6k%enNopTT_82te*r-TvHi64O#yDJEQRD#(%k4(+#(r
zkud46HfGUf(iJdqW4ypS_vaRn0-gmX$M-Fi-c)r$PGNDoPeY1BfRmBJi6sjg!e*LW
m>e1;;m#^vYGVP7sBEMby$p5aR3swR{fWgz%&t;ucLK6UzV!cNI

literal 1156
zcmV-~1bh35P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F800004XF*Lt006O%
z3;baP000C#Nkl<ZSP8{fU1(fI6#i!Ky}R4|EQMe#>9(dC8rw}1A8fR~NFi-$)rjbe
zR;1V$8;TDFpZq2Dhk_`ASSo@DRTM?jmEwbFwAeP-`cjD)4N00T)zSu%o85GO?(TTb
z?B3<xyEn<Y$<l${nKS3i`Ocg<bLL!uDqAcT3z}wr7a;qj#5P*iTKchutNarJe*hvL
ziD*M3BO_U6EZ4+x0&Q)v_4&N@3IQJ=;K*|F%qK%k`u|kZ^nuCAk$;z3v#0^>?fXKR
z%=n80dX&H$mr}AgPo&70cS4~%-xwSFF5@TXYXI-svU1<hg8Tgz)i5`#>&9b#-l#BO
z^X87OTuz=LkZ27+OD#zNf&GcZpT9eWTn3bOez6YVHfDl6vBT+!fX(4EFS&iScWy&)
zA7u>2vL`ir(AcQGO5+1IUB^C}&(BKJoEc&abp%D%TVvHk``XKN)t6{;K8eEg739wT
zjLat=L#9$b(jukndOIJ5I)c(Yukot6^^4{vXxm~4Ki7}u!80&=_qYWVB^!&F<bh&_
z%U!QF$@pk<O$AyvK-;<%;e*dY>%K?vQqLbj?x!DJa-6Ip5#u&39B%2AQXX<~S3t=5
zc@!qbksbURC={Ug+y`UlPUOCgLoO^hHHWfUoYOhCJ7?{&eb%#Gob~~mw)uWN0~97F
zkooKsvhmYMpF9DrvlGUHyAVEn1PjMr^DL8nfzrd`Vbn&7h6Z*14X?k2(34LoCFu`O
zs@~|`U7?h*MKszmN?zDf!L4CJw6q}fNFTySUr@(jKKd|3&_LwEB?!a7+ygz3$)rQG
z_=|4=KdY<K<jf4xUwp1~iQCt!US@MZ#(tTl7pJwH3B8<JY3+_SwX`rjrF!;&XrdcV
z0V$IeIYF`kTuiLItyu%Tb2}PdqSAqyb?z6{Yume3pC9{M^`5_f=oTmg7L9>wqTizw
zg&Q}J{-_vy!F>-YwsrAWuNc!;1I04RkM}?4(rL(R*O2?+d!!CNt=z43+>PMlPbfv1
zQfxT2GB$ZY#OW6FI~mTgod=wA)r_^SZZy63KA>sHQeNQvP}xLW=K|6+3+75wv1o2a
zU_%svO`8zhy%)xwy|gz0>%w{5eE01N>|!d`hSY1gabw2^l#UNqNcl|IF=2bgrYl4#
z>a$;ciJQmYgv`-Z^fV#FiRtOlehxzNl0INr)-%;S#~wXpQqo<Q<{Ul6Q?P!!gzV`-
z6sE3}`R;*8F(%KIOEU7p0D0kMw_trJ+Wj%wy}GaEM8u^t!4203(xr8{grz3S9$@O0
z7Nu+emq>;oICCVJUgbtQ1N)s7G3zfMfekh>F?yLxXQEg0IQYY4hxeO+G0Ro4Z2<SP
zv)7aB*7cm?>XqX3UYZIz`PGm4(@Y!>hwnNxK7M}AZ=EX!`~)~IZpp`~*O+>Jp8p4_
W+@I<z535W70000<MNUMnLSTZRrZ;8)


From a2139b7718e20d70698e1e4daf1890ea09c167e6 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Wed, 11 Dec 2024 10:45:51 -0800
Subject: [PATCH 05/99] Add indexer server, add some basic security config,
 updated historical and broker to use the common druid root directory

---
 .../_common/common.runtime.properties         | 36 +++++++++++++++++--
 .../broker/runtime.properties                 |  2 +-
 .../historical/runtime.properties             |  4 +--
 .../micro-quickstart/indexer/jvm.config       | 10 ++++++
 .../micro-quickstart/indexer/main.config      |  1 +
 .../indexer/runtime.properties                | 24 +++++++++++++
 .../single-server/micro-quickstart.conf       |  2 +-
 .../datasources-view/datasources-view.tsx     |  1 +
 .../src/views/tasks-view/tasks-view.tsx       |  1 +
 9 files changed, 75 insertions(+), 6 deletions(-)
 create mode 100644 examples/conf/druid/single-server/micro-quickstart/indexer/jvm.config
 create mode 100644 examples/conf/druid/single-server/micro-quickstart/indexer/main.config
 create mode 100644 examples/conf/druid/single-server/micro-quickstart/indexer/runtime.properties

diff --git a/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties b/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties
index ad69643b83d9..372ee58ac5e6 100644
--- a/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties
+++ b/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties
@@ -24,12 +24,44 @@
 # If you specify `druid.extensions.loadList=[]`, Druid won't load any extension from file system.
 # If you don't specify `druid.extensions.loadList`, Druid will load all the extensions under root extension directory.
 # More info: https://druid.apache.org/docs/latest/operations/including-extensions.html
-druid.extensions.loadList=["druid-s3-extensions","postgresql-metadata-storage", "druid-hdfs-storage", "druid-kafka-indexing-service", "druid-datasketches", "druid-multi-stage-query", "druid-parquet-extensions"]
+druid.extensions.loadList=["druid-basic-security", "druid-s3-extensions","postgresql-metadata-storage", "druid-hdfs-storage", "druid-kafka-indexing-service", "druid-datasketches", "druid-multi-stage-query", "druid-parquet-extensions"]
 
 # If you have a different version of Hadoop, place your Hadoop client jar files in your hadoop-dependencies directory
 # and uncomment the line below to point to your directory.
 #druid.extensions.hadoopDependenciesDir=/my/dir/hadoop-dependencies
 
+# poll every 60 min
+druid.auth.basic.common.pollingPeriod = 3600000
+
+# Druid basic security
+druid.auth.authenticatorChain=["MyBasicMetadataAuthenticator"]
+druid.auth.authenticator.MyBasicMetadataAuthenticator.type=basic
+
+# Default password for 'admin' user, should be changed for production.
+druid.auth.authenticator.MyBasicMetadataAuthenticator.initialAdminPassword=password1
+
+# Default password for internal 'druid_system' user, should be changed for production.
+druid.auth.authenticator.MyBasicMetadataAuthenticator.initialInternalClientPassword=password2
+
+# Uses the metadata store for storing users.
+# You can use the authentication API to create new users and grant permissions
+druid.auth.authenticator.MyBasicMetadataAuthenticator.credentialsValidator.type=metadata
+
+# If true and if the request credential doesn't exist in this credentials store,
+# the request will proceed to next Authenticator in the chain.
+druid.auth.authenticator.MyBasicMetadataAuthenticator.skipOnFailure=false
+
+druid.auth.authenticator.MyBasicMetadataAuthenticator.authorizerName=MyBasicMetadataAuthorizer
+
+# Escalator
+druid.escalator.type=basic
+druid.escalator.internalClientUsername=druid_system
+druid.escalator.internalClientPassword=password2
+druid.escalator.authorizerName=MyBasicMetadataAuthorizer
+
+druid.auth.authorizers=["MyBasicMetadataAuthorizer"]
+
+druid.auth.authorizer.MyBasicMetadataAuthorizer.type=basic
 
 #
 # Hostname
@@ -97,7 +129,7 @@ druid.storage.storageDirectory=/Users/cecemei/codespace/var/druid/segments
 
 # For local disk (only viable in a cluster if this is a network mount):
 druid.indexer.logs.type=file
-druid.indexer.logs.directory=var/druid/indexing-logs
+druid.indexer.logs.directory=/Users/cecemei/codespace/var/druid/indexing-logs
 
 # For HDFS:
 #druid.indexer.logs.type=hdfs
diff --git a/examples/conf/druid/single-server/micro-quickstart/broker/runtime.properties b/examples/conf/druid/single-server/micro-quickstart/broker/runtime.properties
index 92b85f8bc754..a7c492bc4631 100644
--- a/examples/conf/druid/single-server/micro-quickstart/broker/runtime.properties
+++ b/examples/conf/druid/single-server/micro-quickstart/broker/runtime.properties
@@ -30,7 +30,7 @@ druid.broker.http.maxQueuedBytes=5MiB
 # Processing threads and buffers
 druid.processing.buffer.sizeBytes=100MiB
 druid.processing.numMergeBuffers=2
-druid.processing.tmpDir=var/druid/processing
+druid.processing.tmpDir=/Users/cecemei/codespace/var/druid/processing
 
 # Query cache disabled -- push down caching and merging instead
 druid.broker.cache.useCache=false
diff --git a/examples/conf/druid/single-server/micro-quickstart/historical/runtime.properties b/examples/conf/druid/single-server/micro-quickstart/historical/runtime.properties
index 76eaa5d4b0cd..aa16b2cc2d29 100644
--- a/examples/conf/druid/single-server/micro-quickstart/historical/runtime.properties
+++ b/examples/conf/druid/single-server/micro-quickstart/historical/runtime.properties
@@ -27,10 +27,10 @@ druid.server.http.numThreads=12
 druid.processing.buffer.sizeBytes=200MiB
 druid.processing.numMergeBuffers=2
 druid.processing.numThreads=2
-druid.processing.tmpDir=var/druid/processing
+druid.processing.tmpDir=/Users/cecemei/codespace/var/druid/processing
 
 # Segment storage
-druid.segmentCache.locations=[{"path":"var/druid/segment-cache","maxSize":"300g"}]
+druid.segmentCache.locations=[{"path":"/Users/cecemei/codespace/var/druid/segment-cache","maxSize":"300g"}]
 
 # Query cache
 druid.historical.cache.useCache=true
diff --git a/examples/conf/druid/single-server/micro-quickstart/indexer/jvm.config b/examples/conf/druid/single-server/micro-quickstart/indexer/jvm.config
new file mode 100644
index 000000000000..bd1d6021fb03
--- /dev/null
+++ b/examples/conf/druid/single-server/micro-quickstart/indexer/jvm.config
@@ -0,0 +1,10 @@
+-server
+-Xms1g
+-Xmx1g
+-XX:MaxDirectMemorySize=1280m
+-XX:+ExitOnOutOfMemoryError
+-Duser.timezone=UTC
+-Dfile.encoding=UTF-8
+-Djava.io.tmpdir=var/tmp
+-Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager
+-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5104
diff --git a/examples/conf/druid/single-server/micro-quickstart/indexer/main.config b/examples/conf/druid/single-server/micro-quickstart/indexer/main.config
new file mode 100644
index 000000000000..5183399415cf
--- /dev/null
+++ b/examples/conf/druid/single-server/micro-quickstart/indexer/main.config
@@ -0,0 +1 @@
+org.apache.druid.cli.Main server indexer
diff --git a/examples/conf/druid/single-server/micro-quickstart/indexer/runtime.properties b/examples/conf/druid/single-server/micro-quickstart/indexer/runtime.properties
new file mode 100644
index 000000000000..6e95c055e11d
--- /dev/null
+++ b/examples/conf/druid/single-server/micro-quickstart/indexer/runtime.properties
@@ -0,0 +1,24 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+druid.service=druid/indexer
+druid.plaintextPort=8184
+
+# HTTP server threads
+druid.server.http.numThreads=12
diff --git a/examples/conf/supervise/single-server/micro-quickstart.conf b/examples/conf/supervise/single-server/micro-quickstart.conf
index 78d43a3fd812..69dff0f631cf 100644
--- a/examples/conf/supervise/single-server/micro-quickstart.conf
+++ b/examples/conf/supervise/single-server/micro-quickstart.conf
@@ -8,4 +8,4 @@ coordinator-overlord bin/run-druid coordinator-overlord conf/druid/single-server
 broker bin/run-druid broker conf/druid/single-server/micro-quickstart
 router bin/run-druid router conf/druid/single-server/micro-quickstart
 historical bin/run-druid historical conf/druid/single-server/micro-quickstart
-!p90 middleManager bin/run-druid middleManager conf/druid/single-server/micro-quickstart
+!p90 indexer bin/run-druid indexer conf/druid/single-server/micro-quickstart
diff --git a/web-console/src/views/datasources-view/datasources-view.tsx b/web-console/src/views/datasources-view/datasources-view.tsx
index 96a32c545ab7..fa848ac4b8a3 100644
--- a/web-console/src/views/datasources-view/datasources-view.tsx
+++ b/web-console/src/views/datasources-view/datasources-view.tsx
@@ -654,6 +654,7 @@ GROUP BY 1, 2`;
   }
 
   private readonly refresh = (auto: boolean): void => {
+    if (1 > 0) return; // skip refresh
     if (auto && hasPopoverOpen()) return;
     this.datasourceQueryManager.rerunLastQuery(auto);
   };
diff --git a/web-console/src/views/tasks-view/tasks-view.tsx b/web-console/src/views/tasks-view/tasks-view.tsx
index 5e3d59f06a19..df346c44887d 100644
--- a/web-console/src/views/tasks-view/tasks-view.tsx
+++ b/web-console/src/views/tasks-view/tasks-view.tsx
@@ -587,6 +587,7 @@ ORDER BY
           <RefreshButton
             localStorageKey={LocalStorageKeys.TASKS_REFRESH_RATE}
             onRefresh={auto => {
+              if (1 > 0) return; // skip refresh
               if (auto && hasPopoverOpen()) return;
               this.taskQueryManager.rerunLastQuery(auto);
             }}

From 8640a92e72b5ffa008908dc22af39cb2f08647d5 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Mon, 3 Mar 2025 08:15:50 -0800
Subject: [PATCH 06/99] Some policy config

---
 .../tools/ServerManagerForQueryErrorTest.java |   7 +-
 .../ServerManagerForQueryErrorTest.java       |  19 +-
 pom.xml                                       |   6 +
 .../org/apache/druid/query/DataSource.java    |  11 +
 .../druid/query/RestrictedDataSource.java     |   9 +-
 .../apache/druid/query/TableDataSource.java   |  10 +-
 .../druid/query/policy/PolicyConfig.java      | 144 +++++
 .../druid/segment/RestrictedSegment.java      |  11 +-
 .../apache/druid/query/DataSourceTest.java    |  59 +-
 .../druid/query/policy/PolicyConfigTest.java  |  90 +++
 server/pom.xml                                |   5 +
 .../server/coordination/ServerManager.java    |  10 +-
 .../druid/server/security/AuthConfig.java     |  27 +-
 .../apache/druid/server/TestSegmentUtils.java |  20 +
 .../coordination/SegmentBootstrapperTest.java |  20 +-
 .../SegmentLoadDropHandlerTest.java           |   1 +
 .../coordination/ServerManagerTest.java       | 536 +++++++++---------
 .../utils}/TestSegmentCacheManager.java       |   8 +-
 18 files changed, 680 insertions(+), 313 deletions(-)
 create mode 100644 processing/src/main/java/org/apache/druid/query/policy/PolicyConfig.java
 create mode 100644 processing/src/test/java/org/apache/druid/query/policy/PolicyConfigTest.java
 rename server/src/test/java/org/apache/druid/{server/coordination => test/utils}/TestSegmentCacheManager.java (96%)

diff --git a/integration-tests-ex/tools/src/main/java/org/apache/druid/testing/tools/ServerManagerForQueryErrorTest.java b/integration-tests-ex/tools/src/main/java/org/apache/druid/testing/tools/ServerManagerForQueryErrorTest.java
index 91434232b92c..612d29e3846d 100644
--- a/integration-tests-ex/tools/src/main/java/org/apache/druid/testing/tools/ServerManagerForQueryErrorTest.java
+++ b/integration-tests-ex/tools/src/main/java/org/apache/druid/testing/tools/ServerManagerForQueryErrorTest.java
@@ -50,6 +50,7 @@
 import org.apache.druid.server.SegmentManager;
 import org.apache.druid.server.coordination.ServerManager;
 import org.apache.druid.server.initialization.ServerConfig;
+import org.apache.druid.server.security.AuthConfig;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 
 import java.util.HashSet;
@@ -97,7 +98,8 @@ public ServerManagerForQueryErrorTest(
       Cache cache,
       CacheConfig cacheConfig,
       SegmentManager segmentManager,
-      ServerConfig serverConfig
+      ServerConfig serverConfig,
+      AuthConfig authConfig
   )
   {
     super(
@@ -109,7 +111,8 @@ public ServerManagerForQueryErrorTest(
         cache,
         cacheConfig,
         segmentManager,
-        serverConfig
+        serverConfig,
+        authConfig
     );
   }
 
diff --git a/integration-tests/src/main/java/org/apache/druid/server/coordination/ServerManagerForQueryErrorTest.java b/integration-tests/src/main/java/org/apache/druid/server/coordination/ServerManagerForQueryErrorTest.java
index 6e225304a4a3..ce81720d6847 100644
--- a/integration-tests/src/main/java/org/apache/druid/server/coordination/ServerManagerForQueryErrorTest.java
+++ b/integration-tests/src/main/java/org/apache/druid/server/coordination/ServerManagerForQueryErrorTest.java
@@ -49,6 +49,7 @@
 import org.apache.druid.segment.SegmentReference;
 import org.apache.druid.server.SegmentManager;
 import org.apache.druid.server.initialization.ServerConfig;
+import org.apache.druid.server.security.AuthConfig;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 
 import java.util.Optional;
@@ -58,14 +59,14 @@
 
 /**
  * This server manager is designed to test various query failures.
- *
+ * <p>
  * - Missing segments. A segment can be missing during a query if a historical drops the segment
- *   after the broker issues the query to the historical. To mimic this situation, the historical
- *   with this server manager announces all segments assigned, but reports missing segment for the
- *   first segment of the datasource specified in the query. The missing report is only generated once for the first
- *   segment. Post that report, all segments are served for the datasource. See ITQueryRetryTestOnMissingSegments.
+ * after the broker issues the query to the historical. To mimic this situation, the historical
+ * with this server manager announces all segments assigned, but reports missing segment for the
+ * first segment of the datasource specified in the query. The missing report is only generated once for the first
+ * segment. Post that report, all segments are served for the datasource. See ITQueryRetryTestOnMissingSegments.
  * - Other query errors. This server manager returns a sequence that always throws an exception
- *   based on a given query context value. See ITQueryErrorTest.
+ * based on a given query context value. See ITQueryErrorTest.
  *
  * @see org.apache.druid.query.RetryQueryRunner for query retrying.
  * @see org.apache.druid.client.JsonParserIterator for handling query errors from historicals.
@@ -95,7 +96,8 @@ public ServerManagerForQueryErrorTest(
       Cache cache,
       CacheConfig cacheConfig,
       SegmentManager segmentManager,
-      ServerConfig serverConfig
+      ServerConfig serverConfig,
+      AuthConfig authConfig
   )
   {
     super(
@@ -107,7 +109,8 @@ public ServerManagerForQueryErrorTest(
         cache,
         cacheConfig,
         segmentManager,
-        serverConfig
+        serverConfig,
+        authConfig
     );
   }
 
diff --git a/pom.xml b/pom.xml
index fc7d78ccecb0..797f3447143a 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1336,6 +1336,12 @@
                 <version>1.1.1</version>
                 <scope>test</scope>
             </dependency>
+            <dependency>
+                <groupId>com.google.inject.extensions</groupId>
+                <artifactId>guice-testlib</artifactId>
+                <version>${guice.version}</version>
+                <scope>test</scope>
+            </dependency>
             <dependency>
                 <groupId>com.google.guava</groupId>
                 <artifactId>guava-testlib</artifactId>
diff --git a/processing/src/main/java/org/apache/druid/query/DataSource.java b/processing/src/main/java/org/apache/druid/query/DataSource.java
index 65fb9afe30ee..70c45b8ea65c 100644
--- a/processing/src/main/java/org/apache/druid/query/DataSource.java
+++ b/processing/src/main/java/org/apache/druid/query/DataSource.java
@@ -24,6 +24,7 @@
 import org.apache.druid.query.planning.DataSourceAnalysis;
 import org.apache.druid.query.planning.PreJoinableClause;
 import org.apache.druid.query.policy.Policy;
+import org.apache.druid.query.policy.PolicyConfig;
 import org.apache.druid.segment.SegmentReference;
 import java.util.List;
 import java.util.Map;
@@ -140,6 +141,16 @@ default DataSource withPolicies(Map<String, Optional<Policy>> policyMap)
     return this.withChildren(children);
   }
 
+  /**
+   * Returns true if the datasource complies with the policy restrictions on tables.
+   */
+  default boolean validate(PolicyConfig tableSecurityPolicyConfig)
+  {
+    return this.getChildren()
+               .stream()
+               .allMatch(child -> child.validate(tableSecurityPolicyConfig));
+  }
+
   /**
    * Compute a cache key prefix for a data source. This includes the data sources that participate in the RHS of a
    * join as well as any query specific constructs associated with join data source such as base table filter. This key prefix
diff --git a/processing/src/main/java/org/apache/druid/query/RestrictedDataSource.java b/processing/src/main/java/org/apache/druid/query/RestrictedDataSource.java
index 5b9ad035d84a..54c68f2b768c 100644
--- a/processing/src/main/java/org/apache/druid/query/RestrictedDataSource.java
+++ b/processing/src/main/java/org/apache/druid/query/RestrictedDataSource.java
@@ -27,6 +27,7 @@
 import org.apache.druid.query.planning.DataSourceAnalysis;
 import org.apache.druid.query.policy.NoRestrictionPolicy;
 import org.apache.druid.query.policy.Policy;
+import org.apache.druid.query.policy.PolicyConfig;
 import org.apache.druid.segment.RestrictedSegment;
 import org.apache.druid.segment.SegmentReference;
 
@@ -143,7 +144,7 @@ public DataSource withPolicies(Map<String, Optional<Policy>> policyMap)
     }
 
     Optional<Policy> newPolicy = policyMap.getOrDefault(base.getName(), Optional.empty());
-    if (!newPolicy.isPresent()) {
+    if (newPolicy.isEmpty()) {
       throw new ISE(
           "No restriction found on table [%s], but had policy [%s] before.",
           base.getName(),
@@ -167,6 +168,12 @@ public DataSource withPolicies(Map<String, Optional<Policy>> policyMap)
     return this;
   }
 
+  @Override
+  public boolean validate(PolicyConfig tableSecurityPolicyConfig)
+  {
+    return tableSecurityPolicyConfig.allowPolicy(policy);
+  }
+
   @Override
   public String toString()
   {
diff --git a/processing/src/main/java/org/apache/druid/query/TableDataSource.java b/processing/src/main/java/org/apache/druid/query/TableDataSource.java
index c610de2ca6b3..37e506686437 100644
--- a/processing/src/main/java/org/apache/druid/query/TableDataSource.java
+++ b/processing/src/main/java/org/apache/druid/query/TableDataSource.java
@@ -26,6 +26,7 @@
 import org.apache.druid.java.util.common.IAE;
 import org.apache.druid.query.planning.DataSourceAnalysis;
 import org.apache.druid.query.policy.Policy;
+import org.apache.druid.query.policy.PolicyConfig;
 import org.apache.druid.segment.SegmentReference;
 
 import java.util.Collections;
@@ -115,13 +116,20 @@ public DataSource withUpdatedDataSource(DataSource newSource)
   public DataSource withPolicies(Map<String, Optional<Policy>> policyMap)
   {
     Optional<Policy> policy = policyMap.getOrDefault(name, Optional.empty());
-    if (!policy.isPresent()) {
+    if (policy.isEmpty()) {
       // Skip adding restriction on table if there's no policy restriction found.
       return this;
     }
     return RestrictedDataSource.create(this, policy.get());
   }
 
+  @Override
+  public boolean validate(PolicyConfig tableSecurityPolicyConfig)
+  {
+    // If it reaches here, this table is not wrapped with a RestrictedDataSource (which should overwrite this method).
+    return !tableSecurityPolicyConfig.policyMustBeCheckedAndExistOnAllTables();
+  }
+
   @Override
   public byte[] getCacheKey()
   {
diff --git a/processing/src/main/java/org/apache/druid/query/policy/PolicyConfig.java b/processing/src/main/java/org/apache/druid/query/policy/PolicyConfig.java
new file mode 100644
index 000000000000..37f8e0d940a2
--- /dev/null
+++ b/processing/src/main/java/org/apache/druid/query/policy/PolicyConfig.java
@@ -0,0 +1,144 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.query.policy;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.collect.ImmutableList;
+
+import javax.annotation.Nonnull;
+import java.util.Objects;
+
+/**
+ * Defines how strict we want to enforce the policy on tables during query execution process.
+ */
+public class PolicyConfig
+{
+  @JsonProperty
+  private final TablePolicySecurityLevel tablePolicySecurityLevel;
+
+  @JsonProperty
+  private final ImmutableList<String> allowedPolicies;
+
+  @JsonCreator
+  public PolicyConfig(
+      @JsonProperty("tablePolicySecurityLevel") TablePolicySecurityLevel tablePolicySecurityLevel,
+      @JsonProperty("allowedPolicies") ImmutableList<String> allowedPolicies
+  )
+  {
+    this.tablePolicySecurityLevel = tablePolicySecurityLevel;
+    this.allowedPolicies = allowedPolicies;
+  }
+
+  /**
+   * Returns a {@link PolicyConfig} instance that applies restrictions whenever seen fit, and allows all policy types.
+   */
+  public static PolicyConfig defaultInstance()
+  {
+    return new PolicyConfig(TablePolicySecurityLevel.APPLY_WHEN_APPLICABLE, ImmutableList.of());
+  }
+
+  /**
+   * Returns the table policy security level, higher value means stricter policy.
+   *
+   * @see TablePolicySecurityLevel
+   */
+  @JsonProperty
+  public TablePolicySecurityLevel getTablePolicySecurityLevel()
+  {
+    return tablePolicySecurityLevel;
+  }
+
+  /**
+   * Returns a list of allowed policy class.
+   * <p>
+   * An empty list means all policy classes are allowed.
+   */
+  @JsonProperty
+  public ImmutableList<String> getAllowedPolicies()
+  {
+    return allowedPolicies;
+  }
+
+  public boolean allowPolicy(@Nonnull Policy policy)
+  {
+    return allowedPolicies.isEmpty() || allowedPolicies.contains(policy.getClass().getSimpleName());
+  }
+
+  /**
+   * Returns true if the security level requires that, every table must have a policy during query execution stage,
+   * this means the table must have a non-empty value in the policy map.
+   */
+  public boolean policyMustBeCheckedAndExistOnAllTables()
+  {
+    return tablePolicySecurityLevel.securityLevel >= 2.0;
+  }
+
+  @Override
+  public String toString()
+  {
+    return "PolicyConfig{tablePolicySecurityLevel="
+           + tablePolicySecurityLevel
+           + ", allowedPolicies="
+           + allowedPolicies
+           + '}';
+  }
+
+  @Override
+  public boolean equals(Object o)
+  {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    PolicyConfig that = (PolicyConfig) o;
+    return Objects.equals(tablePolicySecurityLevel, that.tablePolicySecurityLevel) &&
+           Objects.equals(allowedPolicies, that.allowedPolicies);
+  }
+
+  @Override
+  public int hashCode()
+  {
+    return Objects.hash(tablePolicySecurityLevel, allowedPolicies);
+  }
+
+
+  /**
+   * Defines how strict we want to enforce the policy on tables during query execution process.
+   * <ol>
+   *   <li>{@code APPLY_WHEN_APPLICABLE}, the most basic level, restriction is applied whenever seen fit.
+   *   <li>{@code POLICY_CHECKED_ON_ALL_TABLES_POLICY_MUST_EXIST}, every table must have a policy when requests come from external users.
+   * </ol>
+   */
+  public enum TablePolicySecurityLevel
+  {
+    @JsonProperty("0") APPLY_WHEN_APPLICABLE(0f),
+    @JsonProperty("2.0f") POLICY_CHECKED_ON_ALL_TABLES_POLICY_MUST_EXIST(2.0f);
+
+    private final float securityLevel;
+
+    TablePolicySecurityLevel(float securityLevel)
+    {
+      this.securityLevel = securityLevel;
+    }
+  }
+}
diff --git a/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java b/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java
index c4a7cb4828e8..2902afe2949c 100644
--- a/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java
+++ b/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java
@@ -19,6 +19,7 @@
 
 package org.apache.druid.segment;
 
+import com.google.common.annotations.VisibleForTesting;
 import org.apache.druid.query.policy.NoRestrictionPolicy;
 import org.apache.druid.query.policy.Policy;
 import org.apache.druid.timeline.SegmentId;
@@ -42,13 +43,11 @@
  */
 public class RestrictedSegment implements SegmentReference
 {
-  protected final SegmentReference delegate;
-  protected final Policy policy;
+  @VisibleForTesting
+  public final SegmentReference delegate;
+  final Policy policy;
 
-  public RestrictedSegment(
-      SegmentReference delegate,
-      Policy policy
-  )
+  public RestrictedSegment(SegmentReference delegate, Policy policy)
   {
     this.delegate = delegate;
     this.policy = policy;
diff --git a/processing/src/test/java/org/apache/druid/query/DataSourceTest.java b/processing/src/test/java/org/apache/druid/query/DataSourceTest.java
index 25733b340f16..0b639befda2f 100644
--- a/processing/src/test/java/org/apache/druid/query/DataSourceTest.java
+++ b/processing/src/test/java/org/apache/druid/query/DataSourceTest.java
@@ -20,6 +20,7 @@
 package org.apache.druid.query;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
@@ -30,6 +31,7 @@
 import org.apache.druid.query.groupby.GroupByQuery;
 import org.apache.druid.query.policy.NoRestrictionPolicy;
 import org.apache.druid.query.policy.Policy;
+import org.apache.druid.query.policy.PolicyConfig;
 import org.apache.druid.query.policy.RowFilterPolicy;
 import org.apache.druid.segment.TestHelper;
 import org.junit.Assert;
@@ -122,7 +124,7 @@ public void testUnionDataSource() throws Exception
   }
 
   @Test
-  public void testMapWithRestriction()
+  public void testWithPolicies()
   {
     TableDataSource table1 = TableDataSource.create("table1");
     TableDataSource table2 = TableDataSource.create("table2");
@@ -163,7 +165,7 @@ public void testMapWithRestriction()
   }
 
   @Test
-  public void testMapWithRestriction_onRestrictedDataSource_fromDruidSystem()
+  public void testWithPolicies_onRestrictedDataSource_fromDruidSystem()
   {
     RestrictedDataSource restrictedDataSource = RestrictedDataSource.create(
         TableDataSource.create("table1"),
@@ -179,7 +181,7 @@ public void testMapWithRestriction_onRestrictedDataSource_fromDruidSystem()
   }
 
   @Test
-  public void testMapWithRestriction_onRestrictedDataSource_samePolicy()
+  public void testWithPolicies_onRestrictedDataSource_samePolicy()
   {
     RestrictedDataSource restrictedDataSource = RestrictedDataSource.create(
         TableDataSource.create("table1"),
@@ -194,7 +196,7 @@ public void testMapWithRestriction_onRestrictedDataSource_samePolicy()
   }
 
   @Test
-  public void testMapWithRestriction_onRestrictedDataSource_alwaysThrows()
+  public void testWithPolicies_onRestrictedDataSource_alwaysThrows()
   {
     RestrictedDataSource restrictedDataSource = RestrictedDataSource.create(
         TableDataSource.create("table1"),
@@ -221,4 +223,53 @@ public void testMapWithRestriction_onRestrictedDataSource_alwaysThrows()
     ISE e3 = Assert.assertThrows(ISE.class, () -> restrictedDataSource.withPolicies(policyWasNotChecked));
     Assert.assertEquals("Missing policy check result for table [table1]", e3.getMessage());
   }
+
+  @Test
+  public void testValidate_onRestrictedDataSource()
+  {
+    RestrictedDataSource restrictedDataSource = RestrictedDataSource.create(
+        TableDataSource.create("table1"),
+        RowFilterPolicy.from(new NullFilter("random-column", null))
+    );
+    Assert.assertTrue(restrictedDataSource.validate(PolicyConfig.defaultInstance()));
+    // Fail, only NoRestrictionPolicy is allowed.
+    Assert.assertFalse(restrictedDataSource.validate(new PolicyConfig(
+        PolicyConfig.TablePolicySecurityLevel.POLICY_CHECKED_ON_ALL_TABLES_POLICY_MUST_EXIST,
+        ImmutableList.of(NoRestrictionPolicy.class.getSimpleName())
+    )));
+  }
+
+  @Test
+  public void testValidate_onTableDataSource()
+  {
+    TableDataSource tableDataSource = TableDataSource.create("table1");
+    Assert.assertTrue(tableDataSource.validate(PolicyConfig.defaultInstance()));
+    // Fail, policy must exist on table
+    Assert.assertFalse(tableDataSource.validate(new PolicyConfig(
+        PolicyConfig.TablePolicySecurityLevel.POLICY_CHECKED_ON_ALL_TABLES_POLICY_MUST_EXIST,
+        ImmutableList.of()
+    )));
+  }
+
+  @Test
+  public void testValidate_onUnionDataSource()
+  {
+    UnionDataSource unionDataSource = new UnionDataSource(Lists.newArrayList(
+        RestrictedDataSource.create(
+            TableDataSource.create("table1"),
+            RowFilterPolicy.from(new NullFilter("random-column", null))
+        ),
+        TableDataSource.create("table2")));
+    Assert.assertTrue(unionDataSource.validate(PolicyConfig.defaultInstance()));
+    // Fail, policy must exist on table
+    Assert.assertFalse(unionDataSource.validate(new PolicyConfig(
+        PolicyConfig.TablePolicySecurityLevel.POLICY_CHECKED_ON_ALL_TABLES_POLICY_MUST_EXIST,
+        ImmutableList.of()
+    )));
+    // Fail, only NoRestrictionPolicy is allowed.
+    Assert.assertFalse(unionDataSource.validate(new PolicyConfig(
+        PolicyConfig.TablePolicySecurityLevel.APPLY_WHEN_APPLICABLE,
+        ImmutableList.of(NoRestrictionPolicy.class.getSimpleName())
+    )));
+  }
 }
diff --git a/processing/src/test/java/org/apache/druid/query/policy/PolicyConfigTest.java b/processing/src/test/java/org/apache/druid/query/policy/PolicyConfigTest.java
new file mode 100644
index 000000000000..7f7232a9b2a5
--- /dev/null
+++ b/processing/src/test/java/org/apache/druid/query/policy/PolicyConfigTest.java
@@ -0,0 +1,90 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.query.policy;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.collect.ImmutableList;
+import nl.jqno.equalsverifier.EqualsVerifier;
+import org.apache.druid.query.filter.NullFilter;
+import org.apache.druid.segment.TestHelper;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class PolicyConfigTest
+{
+
+  @Test
+  public void test_equals()
+  {
+    EqualsVerifier.forClass(PolicyConfig.class).usingGetClass().verify();
+  }
+
+  @Test
+  public void test_deserialize_fromString() throws Exception
+  {
+    ObjectMapper jsonMapper = TestHelper.makeJsonMapper();
+    PolicyConfig deserialized = jsonMapper.readValue(
+        "{\"tablePolicySecurityLevel\":\"2.0f\",\"allowedPolicies\":[\"NoRestrictionPolicy\",\"RowFilterPolicy\"]}",
+        PolicyConfig.class
+    );
+    Assert.assertEquals(new PolicyConfig(
+        PolicyConfig.TablePolicySecurityLevel.POLICY_CHECKED_ON_ALL_TABLES_POLICY_MUST_EXIST,
+        ImmutableList.of(NoRestrictionPolicy.class.getSimpleName(), RowFilterPolicy.class.getSimpleName())
+    ), deserialized);
+  }
+
+  @Test
+  public void test_serde_roundTrip() throws Exception
+  {
+    final PolicyConfig policyConfig = PolicyConfig.defaultInstance();
+    ObjectMapper jsonMapper = TestHelper.makeJsonMapper();
+    PolicyConfig deserialized = jsonMapper.readValue(jsonMapper.writeValueAsString(policyConfig), PolicyConfig.class);
+    Assert.assertEquals(policyConfig, deserialized);
+  }
+
+  @Test
+  public void test_policyMustBeCheckedAndExistOnAllTables() throws Exception
+  {
+    PolicyConfig defaultConfig = PolicyConfig.defaultInstance();
+    PolicyConfig config = new PolicyConfig(
+        PolicyConfig.TablePolicySecurityLevel.POLICY_CHECKED_ON_ALL_TABLES_POLICY_MUST_EXIST,
+        ImmutableList.of(NoRestrictionPolicy.class.getSimpleName())
+    );
+
+    Assert.assertFalse(defaultConfig.policyMustBeCheckedAndExistOnAllTables());
+    Assert.assertTrue(config.policyMustBeCheckedAndExistOnAllTables());
+  }
+
+  @Test
+  public void test_allowPolicy() throws Exception
+  {
+    PolicyConfig defaultConfig = PolicyConfig.defaultInstance();
+    PolicyConfig config = new PolicyConfig(
+        PolicyConfig.TablePolicySecurityLevel.POLICY_CHECKED_ON_ALL_TABLES_POLICY_MUST_EXIST,
+        ImmutableList.of(NoRestrictionPolicy.class.getSimpleName())
+    );
+    RowFilterPolicy policy = RowFilterPolicy.from(new NullFilter("some-col", null));
+
+    Assert.assertTrue(defaultConfig.allowPolicy(policy));
+    Assert.assertFalse(config.allowPolicy(policy));
+    Assert.assertEquals(ImmutableList.of(NoRestrictionPolicy.class.getSimpleName()), config.getAllowedPolicies());
+    Assert.assertEquals(ImmutableList.of(), defaultConfig.getAllowedPolicies());
+  }
+}
diff --git a/server/pom.xml b/server/pom.xml
index eb664b51a9fc..edc8c558db13 100644
--- a/server/pom.xml
+++ b/server/pom.xml
@@ -438,6 +438,11 @@
             <artifactId>system-rules</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.google.inject.extensions</groupId>
+            <artifactId>guice-testlib</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>com.sun.jersey</groupId>
             <artifactId>jersey-grizzly2</artifactId>
diff --git a/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java b/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
index c8b72061db16..61d25c5c4b81 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
@@ -63,6 +63,7 @@
 import org.apache.druid.server.SegmentManager;
 import org.apache.druid.server.SetAndVerifyContextQueryRunner;
 import org.apache.druid.server.initialization.ServerConfig;
+import org.apache.druid.server.security.AuthConfig;
 import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 import org.apache.druid.timeline.partition.PartitionChunk;
@@ -91,6 +92,7 @@ public class ServerManager implements QuerySegmentWalker
   private final CacheConfig cacheConfig;
   private final SegmentManager segmentManager;
   private final ServerConfig serverConfig;
+  private final AuthConfig authConfig;
 
   @Inject
   public ServerManager(
@@ -102,7 +104,8 @@ public ServerManager(
       Cache cache,
       CacheConfig cacheConfig,
       SegmentManager segmentManager,
-      ServerConfig serverConfig
+      ServerConfig serverConfig,
+      AuthConfig authConfig
   )
   {
     this.conglomerate = conglomerate;
@@ -116,6 +119,7 @@ public ServerManager(
     this.cacheConfig = cacheConfig;
     this.segmentManager = segmentManager;
     this.serverConfig = serverConfig;
+    this.authConfig = authConfig;
   }
 
   @Override
@@ -190,6 +194,10 @@ public <T> QueryRunner<T> getQueryRunnerForSegments(Query<T> theQuery, Iterable<
       throw new ISE("Cannot handle subquery: %s", dataSourceFromQuery);
     }
 
+    if (!dataSourceFromQuery.validate(authConfig.getTableSecurityPolicyConfig())) {
+      throw new ISE("Failed security validation with dataSource [%s]", dataSourceFromQuery);
+    }
+
     if (maybeTimeline.isPresent()) {
       timeline = maybeTimeline.get();
     } else {
diff --git a/server/src/main/java/org/apache/druid/server/security/AuthConfig.java b/server/src/main/java/org/apache/druid/server/security/AuthConfig.java
index 4ad6325d8e45..ba3fa2558c3e 100644
--- a/server/src/main/java/org/apache/druid/server/security/AuthConfig.java
+++ b/server/src/main/java/org/apache/druid/server/security/AuthConfig.java
@@ -23,6 +23,7 @@
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.collect.ImmutableSet;
 import org.apache.druid.query.QueryContexts;
+import org.apache.druid.query.policy.PolicyConfig;
 import org.apache.druid.utils.CollectionUtils;
 
 import java.util.Collections;
@@ -63,7 +64,7 @@ public class AuthConfig
 
   public AuthConfig()
   {
-    this(null, null, null, false, false, null, null, false);
+    this(null, null, null, false, false, null, null, false, null);
   }
 
   @JsonProperty
@@ -100,6 +101,9 @@ public AuthConfig()
   @JsonProperty
   private final boolean enableInputSourceSecurity;
 
+  @JsonProperty
+  private final PolicyConfig tableSecurityPolicyConfig;
+
   @JsonCreator
   public AuthConfig(
       @JsonProperty("authenticatorChain") List<String> authenticatorChain,
@@ -109,7 +113,8 @@ public AuthConfig(
       @JsonProperty("authorizeQueryContextParams") boolean authorizeQueryContextParams,
       @JsonProperty("unsecuredContextKeys") Set<String> unsecuredContextKeys,
       @JsonProperty("securedContextKeys") Set<String> securedContextKeys,
-      @JsonProperty("enableInputSourceSecurity") boolean enableInputSourceSecurity
+      @JsonProperty("enableInputSourceSecurity") boolean enableInputSourceSecurity,
+      @JsonProperty("tableSecurityPolicyConfig") PolicyConfig tableSecurityPolicyConfig
   )
   {
     this.authenticatorChain = authenticatorChain;
@@ -122,6 +127,9 @@ public AuthConfig(
                                 : unsecuredContextKeys;
     this.securedContextKeys = securedContextKeys;
     this.enableInputSourceSecurity = enableInputSourceSecurity;
+    this.tableSecurityPolicyConfig = tableSecurityPolicyConfig == null
+                                     ? PolicyConfig.defaultInstance()
+                                     : tableSecurityPolicyConfig;
   }
 
   public List<String> getAuthenticatorChain()
@@ -154,6 +162,11 @@ public boolean isEnableInputSourceSecurity()
     return enableInputSourceSecurity;
   }
 
+  public PolicyConfig getTableSecurityPolicyConfig()
+  {
+    return tableSecurityPolicyConfig;
+  }
+
   /**
    * Filter the user-supplied context keys based on the context key security
    * rules. If context key security is disabled, then allow all keys. Else,
@@ -252,6 +265,7 @@ public static class Builder
     private Set<String> unsecuredContextKeys;
     private Set<String> securedContextKeys;
     private boolean enableInputSourceSecurity;
+    private PolicyConfig tableSecurityPolicyConfig;
 
     public Builder setAuthenticatorChain(List<String> authenticatorChain)
     {
@@ -301,6 +315,12 @@ public Builder setEnableInputSourceSecurity(boolean enableInputSourceSecurity)
       return this;
     }
 
+    public Builder setTableSecurityPolicyConfig(PolicyConfig tableSecurityPolicyConfig)
+    {
+      this.tableSecurityPolicyConfig = tableSecurityPolicyConfig;
+      return this;
+    }
+
     public AuthConfig build()
     {
       return new AuthConfig(
@@ -311,7 +331,8 @@ public AuthConfig build()
           authorizeQueryContextParams,
           unsecuredContextKeys,
           securedContextKeys,
-          enableInputSourceSecurity
+          enableInputSourceSecurity,
+          tableSecurityPolicyConfig
       );
     }
   }
diff --git a/server/src/test/java/org/apache/druid/server/TestSegmentUtils.java b/server/src/test/java/org/apache/druid/server/TestSegmentUtils.java
index 7cc61d940945..02b4f8c6a277 100644
--- a/server/src/test/java/org/apache/druid/server/TestSegmentUtils.java
+++ b/server/src/test/java/org/apache/druid/server/TestSegmentUtils.java
@@ -45,6 +45,7 @@
 import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.partition.NoneShardSpec;
+import org.apache.druid.timeline.partition.TombstoneShardSpec;
 import org.joda.time.Interval;
 import org.junit.Assert;
 
@@ -253,6 +254,25 @@ public void close()
     }
   }
 
+  public static DataSegment makeTombstoneSegment(String dataSource, String version, Interval interval)
+  {
+    return new DataSegment(
+        dataSource,
+        interval,
+        version,
+        ImmutableMap.of("version", version,
+                        "interval", interval,
+                        "type",
+                        DataSegment.TOMBSTONE_LOADSPEC_TYPE
+        ),
+        Arrays.asList("dim1", "dim2", "dim3"),
+        Arrays.asList("metric1", "metric2"),
+        TombstoneShardSpec.INSTANCE,
+        IndexIO.CURRENT_VERSION_ID,
+        1L
+    );
+  }
+
   public static DataSegment makeSegment(String dataSource, String version, Interval interval)
   {
     return new DataSegment(
diff --git a/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperTest.java b/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperTest.java
index fe1424e27005..461fddf7e48d 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperTest.java
@@ -37,6 +37,7 @@
 import org.apache.druid.segment.loading.StorageLocationConfig;
 import org.apache.druid.server.SegmentManager;
 import org.apache.druid.server.metrics.DataSourceTaskIdHolder;
+import org.apache.druid.test.utils.TestSegmentCacheManager;
 import org.apache.druid.timeline.DataSegment;
 import org.junit.Assert;
 import org.junit.Before;
@@ -186,7 +187,11 @@ public void testLoadCachedSegments() throws Exception
 
     final TestSegmentCacheManager cacheManager = new TestSegmentCacheManager(segments);
     final SegmentManager segmentManager = new SegmentManager(cacheManager);
-    final SegmentLoadDropHandler handler = new SegmentLoadDropHandler(segmentLoaderConfig, segmentAnnouncer, segmentManager);
+    final SegmentLoadDropHandler handler = new SegmentLoadDropHandler(
+        segmentLoaderConfig,
+        segmentAnnouncer,
+        segmentManager
+    );
     final SegmentBootstrapper bootstrapper = new SegmentBootstrapper(
         handler,
         segmentLoaderConfig,
@@ -297,7 +302,10 @@ public void testLoadNoBootstrapSegments() throws Exception
         binder -> {
           binder.bindScope(LazySingleton.class, Scopes.SINGLETON);
           final BroadcastDatasourceLoadingSpec broadcastMode = BroadcastDatasourceLoadingSpec.NONE;
-          binder.bind(Key.get(BroadcastDatasourceLoadingSpec.class, Names.named(DataSourceTaskIdHolder.BROADCAST_DATASOURCES_TO_LOAD_FOR_TASK)))
+          binder.bind(Key.get(
+                    BroadcastDatasourceLoadingSpec.class,
+                    Names.named(DataSourceTaskIdHolder.BROADCAST_DATASOURCES_TO_LOAD_FOR_TASK)
+                ))
                 .toInstance(broadcastMode);
         }
     );
@@ -357,8 +365,12 @@ public void testLoadOnlyRequiredBootstrapSegments() throws Exception
         new LifecycleModule(),
         binder -> {
           binder.bindScope(LazySingleton.class, Scopes.SINGLETON);
-          final BroadcastDatasourceLoadingSpec broadcastMode = BroadcastDatasourceLoadingSpec.loadOnly(ImmutableSet.of("test1"));
-          binder.bind(Key.get(BroadcastDatasourceLoadingSpec.class, Names.named(DataSourceTaskIdHolder.BROADCAST_DATASOURCES_TO_LOAD_FOR_TASK)))
+          final BroadcastDatasourceLoadingSpec broadcastMode = BroadcastDatasourceLoadingSpec.loadOnly(ImmutableSet.of(
+              "test1"));
+          binder.bind(Key.get(
+                    BroadcastDatasourceLoadingSpec.class,
+                    Names.named(DataSourceTaskIdHolder.BROADCAST_DATASOURCES_TO_LOAD_FOR_TASK)
+                ))
                 .toInstance(broadcastMode);
         }
     );
diff --git a/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java b/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
index cd2fe2dbd63e..e34b78606ae5 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
@@ -30,6 +30,7 @@
 import org.apache.druid.segment.loading.StorageLocationConfig;
 import org.apache.druid.server.SegmentManager;
 import org.apache.druid.server.coordination.SegmentChangeStatus.State;
+import org.apache.druid.test.utils.TestSegmentCacheManager;
 import org.apache.druid.timeline.DataSegment;
 import org.junit.Assert;
 import org.junit.Before;
diff --git a/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java b/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
index 438402b94fde..65c15932633d 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
@@ -20,19 +20,28 @@
 package org.apache.druid.server.coordination;
 
 import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.base.Function;
 import com.google.common.base.Functions;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.inject.Guice;
+import com.google.inject.Inject;
+import com.google.inject.testing.fieldbinder.Bind;
+import com.google.inject.testing.fieldbinder.BoundFieldModule;
+import org.apache.druid.client.cache.Cache;
 import org.apache.druid.client.cache.CacheConfig;
+import org.apache.druid.client.cache.CachePopulator;
 import org.apache.druid.client.cache.CachePopulatorStats;
 import org.apache.druid.client.cache.ForegroundCachePopulator;
 import org.apache.druid.client.cache.LocalCacheProvider;
 import org.apache.druid.error.DruidException;
+import org.apache.druid.guice.annotations.Smile;
 import org.apache.druid.jackson.DefaultObjectMapper;
 import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.Intervals;
-import org.apache.druid.java.util.common.MapUtils;
 import org.apache.druid.java.util.common.Pair;
 import org.apache.druid.java.util.common.concurrent.Execs;
 import org.apache.druid.java.util.common.granularity.Granularities;
@@ -43,7 +52,7 @@
 import org.apache.druid.java.util.common.guava.YieldingAccumulator;
 import org.apache.druid.java.util.common.guava.YieldingSequenceBase;
 import org.apache.druid.java.util.emitter.EmittingLogger;
-import org.apache.druid.query.BaseQuery;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
 import org.apache.druid.query.ConcatQueryRunner;
 import org.apache.druid.query.DataSource;
 import org.apache.druid.query.DefaultQueryMetrics;
@@ -61,58 +70,46 @@
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
 import org.apache.druid.query.QueryToolChest;
 import org.apache.druid.query.QueryUnsupportedException;
+import org.apache.druid.query.RestrictedDataSource;
 import org.apache.druid.query.Result;
 import org.apache.druid.query.SegmentDescriptor;
 import org.apache.druid.query.TableDataSource;
 import org.apache.druid.query.aggregation.MetricManipulationFn;
 import org.apache.druid.query.context.DefaultResponseContext;
 import org.apache.druid.query.context.ResponseContext;
-import org.apache.druid.query.filter.DimFilter;
+import org.apache.druid.query.policy.NoRestrictionPolicy;
+import org.apache.druid.query.policy.PolicyConfig;
 import org.apache.druid.query.search.SearchQuery;
 import org.apache.druid.query.search.SearchResultValue;
 import org.apache.druid.query.spec.MultipleSpecificSegmentSpec;
-import org.apache.druid.query.spec.QuerySegmentSpec;
-import org.apache.druid.segment.IndexIO;
 import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.RestrictedSegment;
 import org.apache.druid.segment.Segment;
-import org.apache.druid.segment.TestHelper;
-import org.apache.druid.segment.TestIndex;
-import org.apache.druid.segment.loading.LeastBytesUsedStorageLocationSelectorStrategy;
-import org.apache.druid.segment.loading.SegmentLoaderConfig;
 import org.apache.druid.segment.loading.SegmentLoadingException;
-import org.apache.druid.segment.loading.SegmentLocalCacheManager;
-import org.apache.druid.segment.loading.StorageLocation;
-import org.apache.druid.segment.loading.StorageLocationConfig;
-import org.apache.druid.segment.loading.TombstoneSegmentizerFactory;
 import org.apache.druid.server.SegmentManager;
 import org.apache.druid.server.TestSegmentUtils;
+import org.apache.druid.server.TestSegmentUtils.SegmentForTesting;
 import org.apache.druid.server.initialization.ServerConfig;
 import org.apache.druid.server.metrics.NoopServiceEmitter;
+import org.apache.druid.server.security.AuthConfig;
+import org.apache.druid.test.utils.TestSegmentCacheManager;
 import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.TimelineObjectHolder;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
-import org.apache.druid.timeline.partition.NoneShardSpec;
 import org.apache.druid.timeline.partition.PartitionChunk;
-import org.apache.druid.timeline.partition.TombstoneShardSpec;
-import org.hamcrest.MatcherAssert;
-import org.hamcrest.text.StringContainsInOrder;
 import org.joda.time.Interval;
 import org.junit.Assert;
+import org.junit.Assume;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.rules.TemporaryFolder;
 
-import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
@@ -123,16 +120,49 @@
 
 public class ServerManagerTest
 {
-  @Rule
-  public ExpectedException expectedException = ExpectedException.none();
-
+  private static ImmutableSet<DataSegment> DATA_SEGMENTS = new ImmutableSet.Builder<DataSegment>()
+      .add(TestSegmentUtils.makeSegment("test", "1", Intervals.of("P1d/2011-04-01")))
+      .add(TestSegmentUtils.makeSegment("test", "1", Intervals.of("P1d/2011-04-02")))
+      .add(TestSegmentUtils.makeSegment("test", "2", Intervals.of("P1d/2011-04-02")))
+      .add(TestSegmentUtils.makeSegment("test", "1", Intervals.of("P1d/2011-04-03")))
+      .add(TestSegmentUtils.makeSegment("test", "1", Intervals.of("P1d/2011-04-04")))
+      .add(TestSegmentUtils.makeSegment("test", "1", Intervals.of("P1d/2011-04-05")))
+      .add(TestSegmentUtils.makeSegment("test", "2", Intervals.of("PT1h/2011-04-04T01")))
+      .add(TestSegmentUtils.makeSegment("test", "2", Intervals.of("PT1h/2011-04-04T02")))
+      .add(TestSegmentUtils.makeSegment("test", "2", Intervals.of("PT1h/2011-04-04T03")))
+      .add(TestSegmentUtils.makeSegment("test", "2", Intervals.of("PT1h/2011-04-04T05")))
+      .add(TestSegmentUtils.makeSegment("test", "2", Intervals.of("PT1h/2011-04-04T06")))
+      .add(TestSegmentUtils.makeSegment("test2", "1", Intervals.of("P1d/2011-04-01")))
+      .add(TestSegmentUtils.makeSegment("test2", "1", Intervals.of("P1d/2011-04-02")))
+      .build();
+
+  @Inject
   private ServerManager serverManager;
+
+  @Bind
+  private QueryRunnerFactoryConglomerate conglomerate;
+  @Bind
+  private SegmentManager segmentManager;
+  @Bind
+  private AuthConfig authConfig;
+  @Bind
+  private ServerConfig serverConfig;
+  @Bind
+  private ServiceEmitter serviceEmitter;
+  @Bind
+  private QueryProcessingPool queryProcessingPool;
+  @Bind
+  private CachePopulator cachePopulator;
+  @Bind
+  @Smile
+  private ObjectMapper objectMapper;
+  @Bind
+  private Cache cache;
+  @Bind
+  private CacheConfig cacheConfig;
+
   private MyQueryRunnerFactory factory;
-  private CountDownLatch queryWaitLatch;
-  private CountDownLatch queryWaitYieldLatch;
-  private CountDownLatch queryNotifyLatch;
   private ExecutorService serverManagerExec;
-  private SegmentManager segmentManager;
 
   @Rule
   public TemporaryFolder temporaryFolder = new TemporaryFolder();
@@ -140,86 +170,31 @@ public class ServerManagerTest
   @Before
   public void setUp()
   {
-    final SegmentLoaderConfig loaderConfig = new SegmentLoaderConfig()
-    {
-      @Override
-      public File getInfoDir()
-      {
-        return temporaryFolder.getRoot();
-      }
-
-      @Override
-      public List<StorageLocationConfig> getLocations()
-      {
-        return Collections.singletonList(
-            new StorageLocationConfig(temporaryFolder.getRoot(), null, null)
-        );
-      }
-    };
-
-    final List<StorageLocation> storageLocations = loaderConfig.toStorageLocations();
-    final SegmentLocalCacheManager localCacheManager = new SegmentLocalCacheManager(
-        storageLocations,
-        loaderConfig,
-        new LeastBytesUsedStorageLocationSelectorStrategy(storageLocations),
-        TestIndex.INDEX_IO,
-        TestHelper.makeJsonMapper()
-    )
-    {
-      @Override
-      public ReferenceCountingSegment getSegment(final DataSegment dataSegment)
-      {
-        if (dataSegment.isTombstone()) {
-          return ReferenceCountingSegment
-              .wrapSegment(TombstoneSegmentizerFactory.segmentForTombstone(dataSegment), dataSegment.getShardSpec());
-        } else {
-          return ReferenceCountingSegment.wrapSegment(new TestSegmentUtils.SegmentForTesting(
-              dataSegment.getDataSource(),
-              (Interval) dataSegment.getLoadSpec().get("interval"),
-              MapUtils.getString(dataSegment.getLoadSpec(), "version")
-          ), dataSegment.getShardSpec());
-        }
-      }
-    };
+    serviceEmitter = new NoopServiceEmitter();
+    EmittingLogger.registerEmitter(new NoopServiceEmitter());
+    segmentManager = new SegmentManager(new TestSegmentCacheManager(DATA_SEGMENTS));
+    for (DataSegment segment : DATA_SEGMENTS) {
+      loadQueryable(segment.getDataSource(), segment.getVersion(), segment.getInterval());
+    }
 
-    segmentManager = new SegmentManager(localCacheManager);
+    // By default, we don't want any count-down latch. It's only useful in testing ReferenceCounting.
+    factory = new MyQueryRunnerFactory(new CountDownLatch(1), new CountDownLatch(1), new CountDownLatch(1));
+    // Only SearchQuery is supported in this test.
+    conglomerate = DefaultQueryRunnerFactoryConglomerate.buildFromQueryRunnerFactories(ImmutableMap.of(
+        SearchQuery.class,
+        factory
+    ));
 
-    EmittingLogger.registerEmitter(new NoopServiceEmitter());
-    queryWaitLatch = new CountDownLatch(1);
-    queryWaitYieldLatch = new CountDownLatch(1);
-    queryNotifyLatch = new CountDownLatch(1);
-    factory = new MyQueryRunnerFactory(queryWaitLatch, queryWaitYieldLatch, queryNotifyLatch);
     serverManagerExec = Execs.multiThreaded(2, "ServerManagerTest-%d");
-    QueryRunnerFactoryConglomerate conglomerate = DefaultQueryRunnerFactoryConglomerate.buildFromQueryRunnerFactories(ImmutableMap
-        .<Class<? extends Query>, QueryRunnerFactory>builder()
-        .put(SearchQuery.class, factory)
-        .build());
-    serverManager = new ServerManager(
-        conglomerate,
-        new NoopServiceEmitter(),
-        new ForwardingQueryProcessingPool(serverManagerExec),
-        new ForegroundCachePopulator(new DefaultObjectMapper(), new CachePopulatorStats(), -1),
-        new DefaultObjectMapper(),
-        new LocalCacheProvider().get(),
-        new CacheConfig(),
-        segmentManager,
-        new ServerConfig()
-    );
-
-    loadQueryable("test", "1", Intervals.of("P1d/2011-04-01"));
-    loadQueryable("test", "1", Intervals.of("P1d/2011-04-02"));
-    loadQueryable("test", "2", Intervals.of("P1d/2011-04-02"));
-    loadQueryable("test", "1", Intervals.of("P1d/2011-04-03"));
-    loadQueryable("test", "1", Intervals.of("P1d/2011-04-04"));
-    loadQueryable("test", "1", Intervals.of("P1d/2011-04-05"));
-    loadQueryable("test", "2", Intervals.of("PT1h/2011-04-04T01"));
-    loadQueryable("test", "2", Intervals.of("PT1h/2011-04-04T02"));
-    loadQueryable("test", "2", Intervals.of("PT1h/2011-04-04T03"));
-    loadQueryable("test", "2", Intervals.of("PT1h/2011-04-04T05"));
-    loadQueryable("test", "2", Intervals.of("PT1h/2011-04-04T06"));
-    loadQueryable("test2", "1", Intervals.of("P1d/2011-04-01"));
-    loadQueryable("test2", "1", Intervals.of("P1d/2011-04-02"));
-    loadQueryable("testTombstone", "1", Intervals.of("P1d/2011-04-02"));
+    queryProcessingPool = new ForwardingQueryProcessingPool(serverManagerExec);
+    cachePopulator = new ForegroundCachePopulator(new DefaultObjectMapper(), new CachePopulatorStats(), -1);
+    objectMapper = new DefaultObjectMapper();
+    cache = new LocalCacheProvider().get();
+    cacheConfig = new CacheConfig();
+    serverConfig = new ServerConfig();
+    authConfig = new AuthConfig();
+
+    Guice.createInjector(BoundFieldModule.of(this)).injectMembers(this);
   }
 
   @Test
@@ -229,9 +204,7 @@ public void testSimpleGet()
         Granularities.DAY,
         "test",
         Intervals.of("P1d/2011-04-01"),
-        ImmutableList.of(
-            new Pair<>("1", Intervals.of("P1d/2011-04-01"))
-        )
+        ImmutableList.of(new Pair<>("1", Intervals.of("P1d/2011-04-01")))
     );
     waitForTestVerificationAndCleanup(future);
 
@@ -256,7 +229,6 @@ public void testSimpleGetTombstone()
         Collections.emptyList() // tombstone returns no data
     );
     waitForTestVerificationAndCleanup(future);
-
   }
 
   @Test
@@ -350,7 +322,7 @@ public void testReferenceCounting() throws Exception
         )
     );
 
-    queryNotifyLatch.await(1000, TimeUnit.MILLISECONDS);
+    factory.notifyLatch.await(1000, TimeUnit.MILLISECONDS);
 
     Assert.assertEquals(1, factory.getSegmentReferences().size());
 
@@ -358,7 +330,7 @@ public void testReferenceCounting() throws Exception
       Assert.assertEquals(1, referenceCountingSegment.getNumReferences());
     }
 
-    queryWaitYieldLatch.countDown();
+    factory.waitYieldLatch.countDown();
 
     Assert.assertEquals(1, factory.getAdapters().size());
 
@@ -366,7 +338,7 @@ public void testReferenceCounting() throws Exception
       Assert.assertFalse(segment.isClosed());
     }
 
-    queryWaitLatch.countDown();
+    factory.waitLatch.countDown();
     future.get();
 
     dropQueryable("test", "3", Intervals.of("2011-04-04/2011-04-05"));
@@ -377,7 +349,7 @@ public void testReferenceCounting() throws Exception
   }
 
   @Test
-  public void testReferenceCountingWhileQueryExecuting() throws Exception
+  public void testReferenceCounting_whileQueryExecuting() throws Exception
   {
     loadQueryable("test", "3", Intervals.of("2011-04-04/2011-04-05"));
 
@@ -389,7 +361,7 @@ public void testReferenceCountingWhileQueryExecuting() throws Exception
         )
     );
 
-    queryNotifyLatch.await(1000, TimeUnit.MILLISECONDS);
+    factory.notifyLatch.await(1000, TimeUnit.MILLISECONDS);
 
     Assert.assertEquals(1, factory.getSegmentReferences().size());
 
@@ -397,7 +369,7 @@ public void testReferenceCountingWhileQueryExecuting() throws Exception
       Assert.assertEquals(1, referenceCountingSegment.getNumReferences());
     }
 
-    queryWaitYieldLatch.countDown();
+    factory.waitYieldLatch.countDown();
 
     Assert.assertEquals(1, factory.getAdapters().size());
 
@@ -411,7 +383,7 @@ public void testReferenceCountingWhileQueryExecuting() throws Exception
       Assert.assertFalse(segment.isClosed());
     }
 
-    queryWaitLatch.countDown();
+    factory.waitLatch.countDown();
     future.get();
 
     for (TestSegmentUtils.SegmentForTesting segment : factory.getAdapters()) {
@@ -420,7 +392,7 @@ public void testReferenceCountingWhileQueryExecuting() throws Exception
   }
 
   @Test
-  public void testMultipleDrops() throws Exception
+  public void testReferenceCounting_multipleDrops() throws Exception
   {
     loadQueryable("test", "3", Intervals.of("2011-04-04/2011-04-05"));
 
@@ -432,7 +404,7 @@ public void testMultipleDrops() throws Exception
         )
     );
 
-    queryNotifyLatch.await(1000, TimeUnit.MILLISECONDS);
+    factory.notifyLatch.await(1000, TimeUnit.MILLISECONDS);
 
     Assert.assertEquals(1, factory.getSegmentReferences().size());
 
@@ -440,7 +412,7 @@ public void testMultipleDrops() throws Exception
       Assert.assertEquals(1, referenceCountingSegment.getNumReferences());
     }
 
-    queryWaitYieldLatch.countDown();
+    factory.waitYieldLatch.countDown();
 
     Assert.assertEquals(1, factory.getAdapters().size());
 
@@ -455,7 +427,7 @@ public void testMultipleDrops() throws Exception
       Assert.assertFalse(segment.isClosed());
     }
 
-    queryWaitLatch.countDown();
+    factory.waitLatch.countDown();
     future.get();
 
     for (TestSegmentUtils.SegmentForTesting segment : factory.getAdapters()) {
@@ -464,7 +436,35 @@ public void testMultipleDrops() throws Exception
   }
 
   @Test
-  public void testGetQueryRunnerForIntervalsWhenTimelineIsMissingReturningNoopQueryRunner()
+  public void testReferenceCounting_restrictedSegment() throws Exception
+  {
+    Interval interval = Intervals.of("P1d/2011-04-01");
+    loadQueryable("test", "1", interval);
+    SearchQuery query = searchQuery("test", interval, Granularities.ALL);
+    SearchQuery queryOnRestricted = searchQuery(RestrictedDataSource.create(
+        TableDataSource.create("test"),
+        NoRestrictionPolicy.instance()
+    ), interval, Granularities.ALL);
+
+    Future<?> future = assertQuery(query, interval, ImmutableList.of(new Pair<>("1", interval)));
+    Future<?> future2 = assertQuery(queryOnRestricted, interval, ImmutableList.of(new Pair<>("1", interval)));
+
+    Assert.assertTrue(factory.notifyLatch.await(1000, TimeUnit.MILLISECONDS));
+    Assert.assertEquals(1, factory.getSegmentReferences().size());
+    // Expect 2 references here: 1 for query and 1 for queryOnRestricted
+    Assert.assertEquals(2, factory.getSegmentReferences().get(0).getNumReferences());
+
+    factory.waitYieldLatch.countDown();
+    factory.waitLatch.countDown();
+    future.get();
+    future2.get();
+    Assert.assertEquals(1, factory.getSegmentReferences().size());
+    // no references since both query are finished
+    Assert.assertEquals(0, factory.getSegmentReferences().get(0).getNumReferences());
+  }
+
+  @Test
+  public void testGetQueryRunnerForIntervals_whenTimelineIsMissingReturningNoopQueryRunner()
   {
     final Interval interval = Intervals.of("0000-01-01/P1D");
     final QueryRunner<Result<SearchResultValue>> queryRunner = serverManager.getQueryRunnerForIntervals(
@@ -475,7 +475,7 @@ public void testGetQueryRunnerForIntervalsWhenTimelineIsMissingReturningNoopQuer
   }
 
   @Test
-  public void testGetQueryRunnerForSegmentsWhenTimelineIsMissingReportingMissingSegmentsOnQueryDataSource()
+  public void testGetQueryRunnerForSegments_whenTimelineIsMissingReportingMissingSegmentsOnQueryDataSource()
   {
     final Interval interval = Intervals.of("0000-01-01/P1D");
     final SearchQuery query = searchQueryWithQueryDataSource("unknown_datasource", interval, Granularities.ALL);
@@ -486,52 +486,49 @@ public void testGetQueryRunnerForSegmentsWhenTimelineIsMissingReportingMissingSe
         DruidException.class,
         () -> serverManager.getQueryRunnerForSegments(query, unknownSegments)
     );
-    MatcherAssert.assertThat(
-        e.getMessage(),
-        StringContainsInOrder.stringContainsInOrder(Arrays.asList("Base dataSource", "is not a table!"))
-    );
+    Assert.assertTrue(e.getMessage().startsWith("Base dataSource"));
+    Assert.assertTrue(e.getMessage().endsWith("is not a table!"));
   }
 
   @Test
-  public void testGetQueryRunnerForSegmentsWhenTimelineIsMissingReportingMissingSegments()
+  public void testGetQueryRunnerForSegments_whenTimelineIsMissingReportingMissingSegments()
   {
     final Interval interval = Intervals.of("0000-01-01/P1D");
     final SearchQuery query = searchQuery("unknown_datasource", interval, Granularities.ALL);
     final List<SegmentDescriptor> unknownSegments = Collections.singletonList(
         new SegmentDescriptor(interval, "unknown_version", 0)
     );
-    final QueryRunner<Result<SearchResultValue>> queryRunner = serverManager.getQueryRunnerForSegments(
-        query,
-        unknownSegments
-    );
     final ResponseContext responseContext = DefaultResponseContext.createEmpty();
-    final List<Result<SearchResultValue>> results = queryRunner.run(QueryPlus.wrap(query), responseContext).toList();
+
+    final List<Result<SearchResultValue>> results = serverManager.getQueryRunnerForSegments(query, unknownSegments)
+                                                                 .run(QueryPlus.wrap(query), responseContext)
+                                                                 .toList();
+
     Assert.assertTrue(results.isEmpty());
     Assert.assertNotNull(responseContext.getMissingSegments());
     Assert.assertEquals(unknownSegments, responseContext.getMissingSegments());
   }
 
   @Test
-  public void testGetQueryRunnerForSegmentsWhenTimelineEntryIsMissingReportingMissingSegments()
+  public void testGetQueryRunnerForSegments_whenTimelineEntryIsMissingReportingMissingSegments()
   {
     final Interval interval = Intervals.of("P1d/2011-04-01");
     final SearchQuery query = searchQuery("test", interval, Granularities.ALL);
     final List<SegmentDescriptor> unknownSegments = Collections.singletonList(
         new SegmentDescriptor(interval, "unknown_version", 0)
     );
-    final QueryRunner<Result<SearchResultValue>> queryRunner = serverManager.getQueryRunnerForSegments(
-        query,
-        unknownSegments
-    );
     final ResponseContext responseContext = DefaultResponseContext.createEmpty();
-    final List<Result<SearchResultValue>> results = queryRunner.run(QueryPlus.wrap(query), responseContext).toList();
+
+    final List<Result<SearchResultValue>> results = serverManager.getQueryRunnerForSegments(query, unknownSegments)
+                                                                 .run(QueryPlus.wrap(query), responseContext)
+                                                                 .toList();
     Assert.assertTrue(results.isEmpty());
     Assert.assertNotNull(responseContext.getMissingSegments());
     Assert.assertEquals(unknownSegments, responseContext.getMissingSegments());
   }
 
   @Test
-  public void testGetQueryRunnerForSegmentsWhenTimelinePartitionChunkIsMissingReportingMissingSegments()
+  public void testGetQueryRunnerForSegments_whenTimelinePartitionChunkIsMissingReportingMissingSegments()
   {
     final Interval interval = Intervals.of("P1d/2011-04-01");
     final int unknownPartitionId = 1000;
@@ -551,13 +548,14 @@ public void testGetQueryRunnerForSegmentsWhenTimelinePartitionChunkIsMissingRepo
   }
 
   @Test
-  public void testGetQueryRunnerForSegmentsWhenSegmentIsClosedReportingMissingSegments()
+  public void testGetQueryRunnerForSegments_whenSegmentIsClosedReportingMissingSegments()
   {
     final Interval interval = Intervals.of("P1d/2011-04-01");
     final SearchQuery query = searchQuery("test", interval, Granularities.ALL);
     final Optional<VersionedIntervalTimeline<String, ReferenceCountingSegment>> maybeTimeline = segmentManager
         .getTimeline(query.getDataSourceAnalysis().getBaseTableDataSource());
-    Assert.assertTrue(maybeTimeline.isPresent());
+    Assume.assumeTrue(maybeTimeline.isPresent());
+    // close all segments in interval
     final List<TimelineObjectHolder<String, ReferenceCountingSegment>> holders = maybeTimeline.get().lookup(interval);
     final List<SegmentDescriptor> closedSegments = new ArrayList<>();
     for (TimelineObjectHolder<String, ReferenceCountingSegment> holder : holders) {
@@ -570,86 +568,94 @@ public void testGetQueryRunnerForSegmentsWhenSegmentIsClosedReportingMissingSegm
         segment.close();
       }
     }
-    final QueryRunner<Result<SearchResultValue>> queryRunner = serverManager.getQueryRunnerForSegments(
-        query,
-        closedSegments
-    );
     final ResponseContext responseContext = DefaultResponseContext.createEmpty();
-    final List<Result<SearchResultValue>> results = queryRunner.run(QueryPlus.wrap(query), responseContext).toList();
+
+    final List<Result<SearchResultValue>> results = serverManager.getQueryRunnerForSegments(query, closedSegments)
+                                                                 .run(QueryPlus.wrap(query), responseContext)
+                                                                 .toList();
     Assert.assertTrue(results.isEmpty());
     Assert.assertNotNull(responseContext.getMissingSegments());
     Assert.assertEquals(closedSegments, responseContext.getMissingSegments());
   }
 
   @Test
-  public void testGetQueryRunnerForSegmentsForUnknownQueryThrowingException()
+  public void testGetQueryRunnerForSegments_forUnknownQueryThrowingException()
   {
     final Interval interval = Intervals.of("P1d/2011-04-01");
     final List<SegmentDescriptor> descriptors = Collections.singletonList(new SegmentDescriptor(interval, "1", 0));
-    expectedException.expect(QueryUnsupportedException.class);
-    expectedException.expectMessage("Unknown query type");
-    serverManager.getQueryRunnerForSegments(
-        new BaseQuery<>(
-            new TableDataSource("test"),
-            new MultipleSpecificSegmentSpec(descriptors),
-            new HashMap<>()
-        )
-        {
-          @Override
-          public boolean hasFilters()
-          {
-            return false;
-          }
-
-          @Override
-          public DimFilter getFilter()
-          {
-            return null;
-          }
-
-          @Override
-          public String getType()
-          {
-            return null;
-          }
-
-          @Override
-          public Query<Object> withOverriddenContext(Map<String, Object> contextOverride)
-          {
-            return this;
-          }
-
-          @Override
-          public Query<Object> withQuerySegmentSpec(QuerySegmentSpec spec)
-          {
-            return null;
-          }
+    Query<?> query = Druids.newTimeBoundaryQueryBuilder()
+                           .dataSource("random-ds")
+                           .intervals(interval.toString())
+                           .build();
+    // We only have QueryRunnerFactory for SearchQuery in test.
+    QueryUnsupportedException e = Assert.assertThrows(
+        QueryUnsupportedException.class,
+        () -> serverManager.getQueryRunnerForSegments(query, descriptors)
+    );
+    Assert.assertTrue(e.getMessage().startsWith("Unknown query type"));
+  }
 
-          @Override
-          public Query<Object> withDataSource(DataSource dataSource)
-          {
-            return null;
-          }
-        },
-        descriptors
+  @Test
+  public void testGetQueryRunnerForSegments_restricted() throws Exception
+  {
+    authConfig = AuthConfig.newBuilder()
+                           .setTableSecurityPolicyConfig(new PolicyConfig(
+                               PolicyConfig.TablePolicySecurityLevel.POLICY_CHECKED_ON_ALL_TABLES_POLICY_MUST_EXIST,
+                               ImmutableList.of()
+                           ))
+                           .build();
+    serverManager = Guice.createInjector(BoundFieldModule.of(this)).getInstance(ServerManager.class);
+    Interval interval = Intervals.of("P1d/2011-04-01");
+    SearchQuery query = searchQuery("test", interval, Granularities.ALL);
+    SearchQuery queryOnRestricted = searchQuery(RestrictedDataSource.create(
+        TableDataSource.create("test"),
+        NoRestrictionPolicy.instance()
+    ), interval, Granularities.ALL);
+
+    ISE e = Assert.assertThrows(
+        ISE.class,
+        () -> serverManager.getQueryRunnerForIntervals(query, ImmutableList.of(interval))
     );
+    Assert.assertEquals("Failed security validation with dataSource [test]", e.getMessage());
+    Assert.assertNotNull(serverManager.getQueryRunnerForIntervals(queryOnRestricted, ImmutableList.of(interval)));
   }
 
   private void waitForTestVerificationAndCleanup(Future future)
   {
     try {
-      queryNotifyLatch.await(1000, TimeUnit.MILLISECONDS);
-      queryWaitYieldLatch.countDown();
-      queryWaitLatch.countDown();
+      factory.notifyLatch.await(1000, TimeUnit.MILLISECONDS);
+      factory.waitLatch.countDown();
       future.get();
       factory.clearAdapters();
     }
     catch (Exception e) {
-      throw new RuntimeException(e);
+      throw new RuntimeException(e.getCause());
     }
   }
 
-  private SearchQuery searchQuery(String datasource, Interval interval, Granularity granularity)
+  private static SearchQuery searchQueryWithQueryDataSource(
+      String datasource,
+      Interval interval,
+      Granularity granularity
+  )
+  {
+    final ImmutableList<SegmentDescriptor> descriptors = ImmutableList.of(
+        new SegmentDescriptor(Intervals.of("2000/3000"), "0", 0),
+        new SegmentDescriptor(Intervals.of("2000/3000"), "0", 1)
+    );
+    return searchQuery(new QueryDataSource(Druids.newTimeseriesQueryBuilder()
+                                                 .dataSource(datasource)
+                                                 .intervals(new MultipleSpecificSegmentSpec(descriptors))
+                                                 .granularity(Granularities.ALL)
+                                                 .build()), interval, granularity);
+  }
+
+  private static SearchQuery searchQuery(String datasource, Interval interval, Granularity granularity)
+  {
+    return searchQuery(TableDataSource.create(datasource), interval, granularity);
+  }
+
+  private static SearchQuery searchQuery(DataSource datasource, Interval interval, Granularity granularity)
   {
     return Druids.newSearchQueryBuilder()
                  .dataSource(datasource)
@@ -660,31 +666,36 @@ private SearchQuery searchQuery(String datasource, Interval interval, Granularit
                  .build();
   }
 
-
-  private SearchQuery searchQueryWithQueryDataSource(String datasource, Interval interval, Granularity granularity)
+  private Future<?> assertQuery(
+      SearchQuery query,
+      Interval interval,
+      List<Pair<String, Interval>> expected
+  )
   {
-    final ImmutableList<SegmentDescriptor> descriptors = ImmutableList.of(
-        new SegmentDescriptor(Intervals.of("2000/3000"), "0", 0),
-        new SegmentDescriptor(Intervals.of("2000/3000"), "0", 1)
+    final Iterator<Pair<String, Interval>> expectedIter = expected.iterator();
+    final List<Interval> intervals = Collections.singletonList(interval);
+    final QueryRunner<Result<SearchResultValue>> runner = serverManager.getQueryRunnerForIntervals(query, intervals);
+    return serverManagerExec.submit(
+        () -> {
+          Sequence<Result<SearchResultValue>> seq = runner.run(QueryPlus.wrap(query));
+          seq.toList();
+          Iterator<SegmentForTesting> adaptersIter = factory.getAdapters().iterator();
+
+          while (expectedIter.hasNext() && adaptersIter.hasNext()) {
+            Pair<String, Interval> expectedVals = expectedIter.next();
+            SegmentForTesting value = adaptersIter.next();
+
+            Assert.assertEquals(expectedVals.lhs, value.getVersion());
+            Assert.assertEquals(expectedVals.rhs, value.getInterval());
+          }
+
+          Assert.assertFalse(expectedIter.hasNext());
+          Assert.assertFalse(adaptersIter.hasNext());
+        }
     );
-    return Druids.newSearchQueryBuilder()
-                 .dataSource(
-                     new QueryDataSource(
-                         Druids.newTimeseriesQueryBuilder()
-                               .dataSource(datasource)
-                               .intervals(new MultipleSpecificSegmentSpec(descriptors))
-                               .granularity(Granularities.ALL)
-                               .build()
-                     )
-                 )
-                 .intervals(Collections.singletonList(interval))
-                 .granularity(granularity)
-                 .limit(10000)
-                 .query("wow")
-                 .build();
   }
 
-  private Future assertQueryable(
+  private Future<?> assertQueryable(
       Granularity granularity,
       String dataSource,
       Interval interval,
@@ -694,19 +705,16 @@ private Future assertQueryable(
     final Iterator<Pair<String, Interval>> expectedIter = expected.iterator();
     final List<Interval> intervals = Collections.singletonList(interval);
     final SearchQuery query = searchQuery(dataSource, interval, granularity);
-    final QueryRunner<Result<SearchResultValue>> runner = serverManager.getQueryRunnerForIntervals(
-        query,
-        intervals
-    );
+    final QueryRunner<Result<SearchResultValue>> runner = serverManager.getQueryRunnerForIntervals(query, intervals);
     return serverManagerExec.submit(
         () -> {
           Sequence<Result<SearchResultValue>> seq = runner.run(QueryPlus.wrap(query));
           seq.toList();
-          Iterator<TestSegmentUtils.SegmentForTesting> adaptersIter = factory.getAdapters().iterator();
+          Iterator<SegmentForTesting> adaptersIter = factory.getAdapters().iterator();
 
           while (expectedIter.hasNext() && adaptersIter.hasNext()) {
             Pair<String, Interval> expectedVals = expectedIter.next();
-            TestSegmentUtils.SegmentForTesting value = adaptersIter.next();
+            SegmentForTesting value = adaptersIter.next();
 
             Assert.assertEquals(expectedVals.lhs, value.getVersion());
             Assert.assertEquals(expectedVals.rhs, value.getInterval());
@@ -721,39 +729,10 @@ private Future assertQueryable(
   private void loadQueryable(String dataSource, String version, Interval interval)
   {
     try {
-      if ("testTombstone".equals(dataSource)) {
-        segmentManager.loadSegment(
-            new DataSegment(
-                dataSource,
-                interval,
-                version,
-                ImmutableMap.of("version", version,
-                                "interval", interval,
-                                "type",
-                                DataSegment.TOMBSTONE_LOADSPEC_TYPE
-                ),
-                Arrays.asList("dim1", "dim2", "dim3"),
-                Arrays.asList("metric1", "metric2"),
-                TombstoneShardSpec.INSTANCE,
-                IndexIO.CURRENT_VERSION_ID,
-                1L
-            )
-        );
-      } else {
-        segmentManager.loadSegment(
-            new DataSegment(
-                dataSource,
-                interval,
-                version,
-                ImmutableMap.of("version", version, "interval", interval),
-                Arrays.asList("dim1", "dim2", "dim3"),
-                Arrays.asList("metric1", "metric2"),
-                NoneShardSpec.instance(),
-                IndexIO.CURRENT_VERSION_ID,
-                1L
-            )
-        );
-      }
+      DataSegment segment = "testTombstone".equals(dataSource) ?
+                            TestSegmentUtils.makeTombstoneSegment(dataSource, version, interval) :
+                            TestSegmentUtils.makeSegment(dataSource, version, interval);
+      segmentManager.loadSegment(segment);
     }
     catch (SegmentLoadingException | IOException e) {
       throw new RuntimeException(e);
@@ -762,19 +741,7 @@ private void loadQueryable(String dataSource, String version, Interval interval)
 
   private void dropQueryable(String dataSource, String version, Interval interval)
   {
-    segmentManager.dropSegment(
-        new DataSegment(
-            dataSource,
-            interval,
-            version,
-            ImmutableMap.of("version", version, "interval", interval),
-            Arrays.asList("dim1", "dim2", "dim3"),
-            Arrays.asList("metric1", "metric2"),
-            NoneShardSpec.instance(),
-            IndexIO.CURRENT_VERSION_ID,
-            123L
-        )
-    );
+    segmentManager.dropSegment(TestSegmentUtils.makeSegment(dataSource, version, interval));
   }
 
   private static class MyQueryRunnerFactory implements QueryRunnerFactory<Result<SearchResultValue>, SearchQuery>
@@ -800,14 +767,19 @@ public MyQueryRunnerFactory(
     @Override
     public QueryRunner<Result<SearchResultValue>> createRunner(Segment adapter)
     {
-      if (!(adapter instanceof ReferenceCountingSegment)) {
-        throw new IAE("Expected instance of ReferenceCountingSegment, got %s", adapter.getClass());
+      final ReferenceCountingSegment segment;
+      if (adapter instanceof ReferenceCountingSegment) {
+        segment = (ReferenceCountingSegment) adapter;
+        Assert.assertTrue(segment.getNumReferences() > 0);
+        segmentReferences.add(segment);
+        adapters.add((SegmentForTesting) segment.getBaseSegment());
+      } else if (adapter instanceof RestrictedSegment) {
+        // No access to RestrictedSegment.delegate, but it'd be recorded in segmentReferences. This means we can't test
+        // adapter and segmentReference unless there's already a ReferenceCountingSegment.
+      } else {
+        throw new IAE("Unsupported segment instance: [%s]", adapter.getClass());
       }
-      final ReferenceCountingSegment segment = (ReferenceCountingSegment) adapter;
 
-      Assert.assertTrue(segment.getNumReferences() > 0);
-      segmentReferences.add(segment);
-      adapters.add((TestSegmentUtils.SegmentForTesting) segment.getBaseSegment());
       return new BlockingQueryRunner<>(new NoopQueryRunner<>(), waitLatch, waitYieldLatch, notifyLatch);
     }
 
@@ -826,7 +798,7 @@ public QueryToolChest<Result<SearchResultValue>, SearchQuery> getToolchest()
       return new NoopQueryToolChest<>();
     }
 
-    public List<TestSegmentUtils.SegmentForTesting> getAdapters()
+    public List<SegmentForTesting> getAdapters()
     {
       return adapters;
     }
@@ -865,7 +837,9 @@ public Function<T, T> makePreComputeManipulatorFn(QueryType query, MetricManipul
     @Override
     public TypeReference<T> getResultTypeReference()
     {
-      return new TypeReference<>() {};
+      return new TypeReference<>()
+      {
+      };
     }
   }
 
@@ -896,6 +870,10 @@ public Sequence<T> run(QueryPlus<T> queryPlus, ResponseContext responseContext)
     }
   }
 
+  /**
+   * A Sequence that count-down {@code notifyLatch} when {@link #toYielder} is called, and the returned Yielder waits
+   * for {@code waitYieldLatch} and {@code waitLatch} count-down.
+   */
   private static class BlockingSequence<T> extends YieldingSequenceBase<T>
   {
     private final Sequence<T> baseSequence;
diff --git a/server/src/test/java/org/apache/druid/server/coordination/TestSegmentCacheManager.java b/server/src/test/java/org/apache/druid/test/utils/TestSegmentCacheManager.java
similarity index 96%
rename from server/src/test/java/org/apache/druid/server/coordination/TestSegmentCacheManager.java
rename to server/src/test/java/org/apache/druid/test/utils/TestSegmentCacheManager.java
index 2cd5e8e61feb..54a7d81fc9aa 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/TestSegmentCacheManager.java
+++ b/server/src/test/java/org/apache/druid/test/utils/TestSegmentCacheManager.java
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-package org.apache.druid.server.coordination;
+package org.apache.druid.test.utils;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
@@ -40,7 +40,7 @@
  * methods to support these operations; any other method invoked will throw an exception from the base class,
  * {@link NoopSegmentCacheManager}.
  */
-class TestSegmentCacheManager extends NoopSegmentCacheManager
+public class TestSegmentCacheManager extends NoopSegmentCacheManager
 {
   private final List<DataSegment> cachedSegments;
 
@@ -51,12 +51,12 @@ class TestSegmentCacheManager extends NoopSegmentCacheManager
   private final List<DataSegment> observedSegmentsRemovedFromCache;
   private final AtomicInteger observedShutdownBootstrapCount;
 
-  TestSegmentCacheManager()
+  public TestSegmentCacheManager()
   {
     this(ImmutableSet.of());
   }
 
-  TestSegmentCacheManager(final Set<DataSegment> segmentsToCache)
+  public TestSegmentCacheManager(final Set<DataSegment> segmentsToCache)
   {
     this.cachedSegments = ImmutableList.copyOf(segmentsToCache);
     this.observedBootstrapSegments = new ArrayList<>();

From b086f18030a84aeb4d5472c00a2b9d60d5c55e0f Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Mon, 3 Mar 2025 09:17:32 -0800
Subject: [PATCH 07/99] add checks for SegmentMetadataQuery

---
 .../server/coordination/ServerManager.java    |  4 +-
 .../coordination/ServerManagerTest.java       | 74 +++++++++----------
 2 files changed, 39 insertions(+), 39 deletions(-)

diff --git a/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java b/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
index 61d25c5c4b81..bc7f5131a68a 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
@@ -53,6 +53,7 @@
 import org.apache.druid.query.ReferenceCountingSegmentQueryRunner;
 import org.apache.druid.query.ReportTimelineMissingSegmentQueryRunner;
 import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.query.metadata.metadata.SegmentMetadataQuery;
 import org.apache.druid.query.planning.DataSourceAnalysis;
 import org.apache.druid.query.spec.SpecificSegmentQueryRunner;
 import org.apache.druid.query.spec.SpecificSegmentSpec;
@@ -194,7 +195,8 @@ public <T> QueryRunner<T> getQueryRunnerForSegments(Query<T> theQuery, Iterable<
       throw new ISE("Cannot handle subquery: %s", dataSourceFromQuery);
     }
 
-    if (!dataSourceFromQuery.validate(authConfig.getTableSecurityPolicyConfig())) {
+    if (!(theQuery instanceof SegmentMetadataQuery)
+        && !dataSourceFromQuery.validate(authConfig.getTableSecurityPolicyConfig())) {
       throw new ISE("Failed security validation with dataSource [%s]", dataSourceFromQuery);
     }
 
diff --git a/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java b/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
index 65c15932633d..eaef398ec545 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
@@ -77,13 +77,13 @@
 import org.apache.druid.query.aggregation.MetricManipulationFn;
 import org.apache.druid.query.context.DefaultResponseContext;
 import org.apache.druid.query.context.ResponseContext;
+import org.apache.druid.query.metadata.metadata.SegmentMetadataQuery;
 import org.apache.druid.query.policy.NoRestrictionPolicy;
 import org.apache.druid.query.policy.PolicyConfig;
 import org.apache.druid.query.search.SearchQuery;
 import org.apache.druid.query.search.SearchResultValue;
 import org.apache.druid.query.spec.MultipleSpecificSegmentSpec;
 import org.apache.druid.segment.ReferenceCountingSegment;
-import org.apache.druid.segment.RestrictedSegment;
 import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.loading.SegmentLoadingException;
 import org.apache.druid.server.SegmentManager;
@@ -177,7 +177,6 @@ public void setUp()
       loadQueryable(segment.getDataSource(), segment.getVersion(), segment.getInterval());
     }
 
-    // By default, we don't want any count-down latch. It's only useful in testing ReferenceCounting.
     factory = new MyQueryRunnerFactory(new CountDownLatch(1), new CountDownLatch(1), new CountDownLatch(1));
     // Only SearchQuery is supported in this test.
     conglomerate = DefaultQueryRunnerFactoryConglomerate.buildFromQueryRunnerFactories(ImmutableMap.of(
@@ -438,6 +437,13 @@ public void testReferenceCounting_multipleDrops() throws Exception
   @Test
   public void testReferenceCounting_restrictedSegment() throws Exception
   {
+    factory = new MyQueryRunnerFactory(new CountDownLatch(1), new CountDownLatch(1), new CountDownLatch(2));
+    conglomerate = DefaultQueryRunnerFactoryConglomerate.buildFromQueryRunnerFactories(ImmutableMap.of(
+        SearchQuery.class,
+        factory
+    ));
+    serverManager = Guice.createInjector(BoundFieldModule.of(this)).getInstance(ServerManager.class);
+
     Interval interval = Intervals.of("P1d/2011-04-01");
     loadQueryable("test", "1", interval);
     SearchQuery query = searchQuery("test", interval, Granularities.ALL);
@@ -536,12 +542,10 @@ public void testGetQueryRunnerForSegments_whenTimelinePartitionChunkIsMissingRep
     final List<SegmentDescriptor> unknownSegments = Collections.singletonList(
         new SegmentDescriptor(interval, "1", unknownPartitionId)
     );
-    final QueryRunner<Result<SearchResultValue>> queryRunner = serverManager.getQueryRunnerForSegments(
-        query,
-        unknownSegments
-    );
     final ResponseContext responseContext = DefaultResponseContext.createEmpty();
-    final List<Result<SearchResultValue>> results = queryRunner.run(QueryPlus.wrap(query), responseContext).toList();
+    final List<Result<SearchResultValue>> results = serverManager.getQueryRunnerForSegments(query, unknownSegments)
+                                                                 .run(QueryPlus.wrap(query), responseContext)
+                                                                 .toList();
     Assert.assertTrue(results.isEmpty());
     Assert.assertNotNull(responseContext.getMissingSegments());
     Assert.assertEquals(unknownSegments, responseContext.getMissingSegments());
@@ -598,6 +602,12 @@ public void testGetQueryRunnerForSegments_forUnknownQueryThrowingException()
   @Test
   public void testGetQueryRunnerForSegments_restricted() throws Exception
   {
+    conglomerate = DefaultQueryRunnerFactoryConglomerate.buildFromQueryRunnerFactories(ImmutableMap.of(
+        SearchQuery.class,
+        factory,
+        SegmentMetadataQuery.class,
+        factory
+    ));
     authConfig = AuthConfig.newBuilder()
                            .setTableSecurityPolicyConfig(new PolicyConfig(
                                PolicyConfig.TablePolicySecurityLevel.POLICY_CHECKED_ON_ALL_TABLES_POLICY_MUST_EXIST,
@@ -611,6 +621,10 @@ public void testGetQueryRunnerForSegments_restricted() throws Exception
         TableDataSource.create("test"),
         NoRestrictionPolicy.instance()
     ), interval, Granularities.ALL);
+    SegmentMetadataQuery segmentMetadataQuery = Druids.newSegmentMetadataQueryBuilder()
+                                                      .dataSource("test")
+                                                      .intervals(interval.toString())
+                                                      .build();
 
     ISE e = Assert.assertThrows(
         ISE.class,
@@ -618,6 +632,7 @@ public void testGetQueryRunnerForSegments_restricted() throws Exception
     );
     Assert.assertEquals("Failed security validation with dataSource [test]", e.getMessage());
     Assert.assertNotNull(serverManager.getQueryRunnerForIntervals(queryOnRestricted, ImmutableList.of(interval)));
+    Assert.assertNotNull(serverManager.getQueryRunnerForIntervals(segmentMetadataQuery, ImmutableList.of(interval)));
   }
 
   private void waitForTestVerificationAndCleanup(Future future)
@@ -666,45 +681,25 @@ private static SearchQuery searchQuery(DataSource datasource, Interval interval,
                  .build();
   }
 
-  private Future<?> assertQuery(
-      SearchQuery query,
+  private Future<?> assertQueryable(
+      Granularity granularity,
+      String dataSource,
       Interval interval,
       List<Pair<String, Interval>> expected
   )
   {
-    final Iterator<Pair<String, Interval>> expectedIter = expected.iterator();
-    final List<Interval> intervals = Collections.singletonList(interval);
-    final QueryRunner<Result<SearchResultValue>> runner = serverManager.getQueryRunnerForIntervals(query, intervals);
-    return serverManagerExec.submit(
-        () -> {
-          Sequence<Result<SearchResultValue>> seq = runner.run(QueryPlus.wrap(query));
-          seq.toList();
-          Iterator<SegmentForTesting> adaptersIter = factory.getAdapters().iterator();
-
-          while (expectedIter.hasNext() && adaptersIter.hasNext()) {
-            Pair<String, Interval> expectedVals = expectedIter.next();
-            SegmentForTesting value = adaptersIter.next();
-
-            Assert.assertEquals(expectedVals.lhs, value.getVersion());
-            Assert.assertEquals(expectedVals.rhs, value.getInterval());
-          }
-
-          Assert.assertFalse(expectedIter.hasNext());
-          Assert.assertFalse(adaptersIter.hasNext());
-        }
-    );
+    final SearchQuery query = searchQuery(dataSource, interval, granularity);
+    return assertQuery(query, interval, expected);
   }
 
-  private Future<?> assertQueryable(
-      Granularity granularity,
-      String dataSource,
+  private Future<?> assertQuery(
+      SearchQuery query,
       Interval interval,
       List<Pair<String, Interval>> expected
   )
   {
     final Iterator<Pair<String, Interval>> expectedIter = expected.iterator();
     final List<Interval> intervals = Collections.singletonList(interval);
-    final SearchQuery query = searchQuery(dataSource, interval, granularity);
     final QueryRunner<Result<SearchResultValue>> runner = serverManager.getQueryRunnerForIntervals(query, intervals);
     return serverManagerExec.submit(
         () -> {
@@ -768,14 +763,17 @@ public MyQueryRunnerFactory(
     public QueryRunner<Result<SearchResultValue>> createRunner(Segment adapter)
     {
       final ReferenceCountingSegment segment;
-      if (adapter instanceof ReferenceCountingSegment) {
+      if (this.adapters.stream()
+                       .map(SegmentForTesting::getId)
+                       .anyMatch(segmentId -> adapter.getId().equals(segmentId))) {
+        // Already have adapter for this segment, skip.
+        // For RestrictedSegment, we don't have access to RestrictedSegment.delegate, but it'd be recorded in segmentReferences.
+        // This means we can't test adapter and segmentReference unless there's already a ReferenceCountingSegment.
+      } else if (adapter instanceof ReferenceCountingSegment) {
         segment = (ReferenceCountingSegment) adapter;
         Assert.assertTrue(segment.getNumReferences() > 0);
         segmentReferences.add(segment);
         adapters.add((SegmentForTesting) segment.getBaseSegment());
-      } else if (adapter instanceof RestrictedSegment) {
-        // No access to RestrictedSegment.delegate, but it'd be recorded in segmentReferences. This means we can't test
-        // adapter and segmentReference unless there's already a ReferenceCountingSegment.
       } else {
         throw new IAE("Unsupported segment instance: [%s]", adapter.getClass());
       }

From ff21a3373284ff7c90d259f9d6e048e4c702e8b8 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Mon, 3 Mar 2025 11:29:33 -0800
Subject: [PATCH 08/99] Add thread.sleep for flaky.

---
 .../druid/server/coordination/ServerManagerTest.java  | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java b/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
index eaef398ec545..eb8b4621505a 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
@@ -453,7 +453,14 @@ public void testReferenceCounting_restrictedSegment() throws Exception
     ), interval, Granularities.ALL);
 
     Future<?> future = assertQuery(query, interval, ImmutableList.of(new Pair<>("1", interval)));
-    Future<?> future2 = assertQuery(queryOnRestricted, interval, ImmutableList.of(new Pair<>("1", interval)));
+    // sleep for 1s to make sure the first query hits/finishes factory.createRunner first, since we can't test adapter
+    // and segmentReference for RestrictedSegment unless there's already a ReferenceCountingSegment.
+    Thread.sleep(1000L);
+    Future<?> futureOnRestricted = assertQuery(
+        queryOnRestricted,
+        interval,
+        ImmutableList.of(new Pair<>("1", interval))
+    );
 
     Assert.assertTrue(factory.notifyLatch.await(1000, TimeUnit.MILLISECONDS));
     Assert.assertEquals(1, factory.getSegmentReferences().size());
@@ -463,7 +470,7 @@ public void testReferenceCounting_restrictedSegment() throws Exception
     factory.waitYieldLatch.countDown();
     factory.waitLatch.countDown();
     future.get();
-    future2.get();
+    futureOnRestricted.get();
     Assert.assertEquals(1, factory.getSegmentReferences().size());
     // no references since both query are finished
     Assert.assertEquals(0, factory.getSegmentReferences().get(0).getNumReferences());

From ad864d6e2af259482109e64ead06e0ac5481e113 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Mon, 3 Mar 2025 12:01:38 -0800
Subject: [PATCH 09/99] auth config

---
 .../java/org/apache/druid/server/security/AuthConfig.java  | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/server/src/main/java/org/apache/druid/server/security/AuthConfig.java b/server/src/main/java/org/apache/druid/server/security/AuthConfig.java
index ba3fa2558c3e..9690b0955cc5 100644
--- a/server/src/main/java/org/apache/druid/server/security/AuthConfig.java
+++ b/server/src/main/java/org/apache/druid/server/security/AuthConfig.java
@@ -214,7 +214,8 @@ public boolean equals(Object o)
            && Objects.equals(unsecuredPaths, that.unsecuredPaths)
            && Objects.equals(unsecuredContextKeys, that.unsecuredContextKeys)
            && Objects.equals(securedContextKeys, that.securedContextKeys)
-           && Objects.equals(enableInputSourceSecurity, that.enableInputSourceSecurity);
+           && Objects.equals(enableInputSourceSecurity, that.enableInputSourceSecurity)
+           && Objects.equals(tableSecurityPolicyConfig, that.tableSecurityPolicyConfig);
   }
 
   @Override
@@ -228,7 +229,8 @@ public int hashCode()
         authorizeQueryContextParams,
         unsecuredContextKeys,
         securedContextKeys,
-        enableInputSourceSecurity
+        enableInputSourceSecurity,
+        tableSecurityPolicyConfig
     );
   }
 
@@ -244,6 +246,7 @@ public String toString()
            ", unsecuredContextKeys=" + unsecuredContextKeys +
            ", securedContextKeys=" + securedContextKeys +
            ", enableInputSourceSecurity=" + enableInputSourceSecurity +
+           ", tableSecurityPolicyConfig=" + tableSecurityPolicyConfig +
            '}';
   }
 

From 3b9fabcdb95a8299f494f853c7fc83b500c190d0 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Tue, 4 Mar 2025 19:28:26 -0800
Subject: [PATCH 10/99] format, and remove temp folder rules

---
 .../druid/server/coordination/ServerManagerTest.java     | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java b/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
index eb8b4621505a..382c14c2994b 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
@@ -101,9 +101,7 @@
 import org.junit.Assert;
 import org.junit.Assume;
 import org.junit.Before;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -136,9 +134,6 @@ public class ServerManagerTest
       .add(TestSegmentUtils.makeSegment("test2", "1", Intervals.of("P1d/2011-04-02")))
       .build();
 
-  @Inject
-  private ServerManager serverManager;
-
   @Bind
   private QueryRunnerFactoryConglomerate conglomerate;
   @Bind
@@ -164,8 +159,8 @@ public class ServerManagerTest
   private MyQueryRunnerFactory factory;
   private ExecutorService serverManagerExec;
 
-  @Rule
-  public TemporaryFolder temporaryFolder = new TemporaryFolder();
+  @Inject
+  private ServerManager serverManager;
 
   @Before
   public void setUp()

From cf18a05bdcb42c98baffe495baca2f2d6dc7e94c Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Mon, 31 Mar 2025 00:32:38 -0700
Subject: [PATCH 11/99] added NoopPolicyEnforcer and
 RestrictAllTablesPolicyEnforcer class

---
 .../tools/ServerManagerForQueryErrorTest.java |   6 +-
 .../ServerManagerForQueryErrorTest.java       |  20 +--
 processing/pom.xml                            |   2 +-
 .../org/apache/druid/query/DataSource.java    |   6 +-
 .../druid/query/RestrictedDataSource.java     |   6 +-
 .../apache/druid/query/TableDataSource.java   |   6 +-
 .../query/policy/NoopPolicyEnforcer.java      |  63 ++++++++
 .../druid/query/policy/PolicyConfig.java      | 144 ------------------
 .../druid/query/policy/PolicyEnforcer.java    |  45 ++++++
 .../RestrictAllTablesPolicyEnforcer.java      | 109 +++++++++++++
 .../apache/druid/query/DataSourceTest.java    |  35 ++---
 .../query/policy/NoopPolicyEnforcerTest.java  |  66 ++++++++
 .../druid/query/policy/PolicyConfigTest.java  |  90 -----------
 .../RestrictAllTablesPolicyEnforcerTest.java  |  79 ++++++++++
 .../druid/guice/security/PolicyModule.java    |  37 +++++
 .../initialization/CoreInjectorBuilder.java   |   2 +
 .../server/coordination/ServerManager.java    |  11 +-
 .../druid/server/security/AuthConfig.java     |  34 +----
 .../guice/security/PolicyModuleTest.java      | 109 +++++++++++++
 .../SegmentLoadDropHandlerTest.java           |   1 -
 .../coordination/ServerManagerTest.java       |  16 +-
 21 files changed, 563 insertions(+), 324 deletions(-)
 create mode 100644 processing/src/main/java/org/apache/druid/query/policy/NoopPolicyEnforcer.java
 delete mode 100644 processing/src/main/java/org/apache/druid/query/policy/PolicyConfig.java
 create mode 100644 processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
 create mode 100644 processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java
 create mode 100644 processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java
 delete mode 100644 processing/src/test/java/org/apache/druid/query/policy/PolicyConfigTest.java
 create mode 100644 processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
 create mode 100644 server/src/main/java/org/apache/druid/guice/security/PolicyModule.java
 create mode 100644 server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java

diff --git a/integration-tests-ex/tools/src/main/java/org/apache/druid/testing/tools/ServerManagerForQueryErrorTest.java b/integration-tests-ex/tools/src/main/java/org/apache/druid/testing/tools/ServerManagerForQueryErrorTest.java
index 612d29e3846d..e3b3806b0199 100644
--- a/integration-tests-ex/tools/src/main/java/org/apache/druid/testing/tools/ServerManagerForQueryErrorTest.java
+++ b/integration-tests-ex/tools/src/main/java/org/apache/druid/testing/tools/ServerManagerForQueryErrorTest.java
@@ -45,6 +45,7 @@
 import org.apache.druid.query.ReportTimelineMissingSegmentQueryRunner;
 import org.apache.druid.query.ResourceLimitExceededException;
 import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.segment.ReferenceCountingSegment;
 import org.apache.druid.segment.SegmentReference;
 import org.apache.druid.server.SegmentManager;
@@ -98,8 +99,7 @@ public ServerManagerForQueryErrorTest(
       Cache cache,
       CacheConfig cacheConfig,
       SegmentManager segmentManager,
-      ServerConfig serverConfig,
-      AuthConfig authConfig
+      ServerConfig serverConfig
   )
   {
     super(
@@ -112,7 +112,7 @@ public ServerManagerForQueryErrorTest(
         cacheConfig,
         segmentManager,
         serverConfig,
-        authConfig
+        NoopPolicyEnforcer.instance()
     );
   }
 
diff --git a/integration-tests/src/main/java/org/apache/druid/server/coordination/ServerManagerForQueryErrorTest.java b/integration-tests/src/main/java/org/apache/druid/server/coordination/ServerManagerForQueryErrorTest.java
index ce81720d6847..1e5032c1c126 100644
--- a/integration-tests/src/main/java/org/apache/druid/server/coordination/ServerManagerForQueryErrorTest.java
+++ b/integration-tests/src/main/java/org/apache/druid/server/coordination/ServerManagerForQueryErrorTest.java
@@ -45,11 +45,12 @@
 import org.apache.druid.query.ReportTimelineMissingSegmentQueryRunner;
 import org.apache.druid.query.ResourceLimitExceededException;
 import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.ReferenceCountingSegment;
 import org.apache.druid.segment.SegmentReference;
 import org.apache.druid.server.SegmentManager;
 import org.apache.druid.server.initialization.ServerConfig;
-import org.apache.druid.server.security.AuthConfig;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 
 import java.util.Optional;
@@ -59,14 +60,14 @@
 
 /**
  * This server manager is designed to test various query failures.
- * <p>
+ *
  * - Missing segments. A segment can be missing during a query if a historical drops the segment
- * after the broker issues the query to the historical. To mimic this situation, the historical
- * with this server manager announces all segments assigned, but reports missing segment for the
- * first segment of the datasource specified in the query. The missing report is only generated once for the first
- * segment. Post that report, all segments are served for the datasource. See ITQueryRetryTestOnMissingSegments.
+ *   after the broker issues the query to the historical. To mimic this situation, the historical
+ *   with this server manager announces all segments assigned, but reports missing segment for the
+ *   first segment of the datasource specified in the query. The missing report is only generated once for the first
+ *   segment. Post that report, all segments are served for the datasource. See ITQueryRetryTestOnMissingSegments.
  * - Other query errors. This server manager returns a sequence that always throws an exception
- * based on a given query context value. See ITQueryErrorTest.
+ *   based on a given query context value. See ITQueryErrorTest.
  *
  * @see org.apache.druid.query.RetryQueryRunner for query retrying.
  * @see org.apache.druid.client.JsonParserIterator for handling query errors from historicals.
@@ -96,8 +97,7 @@ public ServerManagerForQueryErrorTest(
       Cache cache,
       CacheConfig cacheConfig,
       SegmentManager segmentManager,
-      ServerConfig serverConfig,
-      AuthConfig authConfig
+      ServerConfig serverConfig
   )
   {
     super(
@@ -110,7 +110,7 @@ public ServerManagerForQueryErrorTest(
         cacheConfig,
         segmentManager,
         serverConfig,
-        authConfig
+        NoopPolicyEnforcer.instance()
     );
   }
 
diff --git a/processing/pom.xml b/processing/pom.xml
index a320ad89c12a..0549bc53cfda 100644
--- a/processing/pom.xml
+++ b/processing/pom.xml
@@ -391,7 +391,7 @@
     <dependency>
       <groupId>org.reflections</groupId>
       <artifactId>reflections</artifactId>
-      <scope>test</scope>
+      <scope>compile</scope>
     </dependency>
     <dependency>
       <groupId>pl.pragmatists</groupId>
diff --git a/processing/src/main/java/org/apache/druid/query/DataSource.java b/processing/src/main/java/org/apache/druid/query/DataSource.java
index 70c45b8ea65c..41d6bf710b3b 100644
--- a/processing/src/main/java/org/apache/druid/query/DataSource.java
+++ b/processing/src/main/java/org/apache/druid/query/DataSource.java
@@ -24,7 +24,7 @@
 import org.apache.druid.query.planning.DataSourceAnalysis;
 import org.apache.druid.query.planning.PreJoinableClause;
 import org.apache.druid.query.policy.Policy;
-import org.apache.druid.query.policy.PolicyConfig;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.SegmentReference;
 import java.util.List;
 import java.util.Map;
@@ -144,11 +144,11 @@ default DataSource withPolicies(Map<String, Optional<Policy>> policyMap)
   /**
    * Returns true if the datasource complies with the policy restrictions on tables.
    */
-  default boolean validate(PolicyConfig tableSecurityPolicyConfig)
+  default boolean validate(PolicyEnforcer policyEnforcer)
   {
     return this.getChildren()
                .stream()
-               .allMatch(child -> child.validate(tableSecurityPolicyConfig));
+               .allMatch(child -> child.validate(policyEnforcer));
   }
 
   /**
diff --git a/processing/src/main/java/org/apache/druid/query/RestrictedDataSource.java b/processing/src/main/java/org/apache/druid/query/RestrictedDataSource.java
index 54c68f2b768c..241104626cb9 100644
--- a/processing/src/main/java/org/apache/druid/query/RestrictedDataSource.java
+++ b/processing/src/main/java/org/apache/druid/query/RestrictedDataSource.java
@@ -27,7 +27,7 @@
 import org.apache.druid.query.planning.DataSourceAnalysis;
 import org.apache.druid.query.policy.NoRestrictionPolicy;
 import org.apache.druid.query.policy.Policy;
-import org.apache.druid.query.policy.PolicyConfig;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.RestrictedSegment;
 import org.apache.druid.segment.SegmentReference;
 
@@ -169,9 +169,9 @@ public DataSource withPolicies(Map<String, Optional<Policy>> policyMap)
   }
 
   @Override
-  public boolean validate(PolicyConfig tableSecurityPolicyConfig)
+  public boolean validate(PolicyEnforcer policyEnforcer)
   {
-    return tableSecurityPolicyConfig.allowPolicy(policy);
+    return policyEnforcer.validate(this);
   }
 
   @Override
diff --git a/processing/src/main/java/org/apache/druid/query/TableDataSource.java b/processing/src/main/java/org/apache/druid/query/TableDataSource.java
index 37e506686437..61fc48bdc376 100644
--- a/processing/src/main/java/org/apache/druid/query/TableDataSource.java
+++ b/processing/src/main/java/org/apache/druid/query/TableDataSource.java
@@ -26,7 +26,7 @@
 import org.apache.druid.java.util.common.IAE;
 import org.apache.druid.query.planning.DataSourceAnalysis;
 import org.apache.druid.query.policy.Policy;
-import org.apache.druid.query.policy.PolicyConfig;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.SegmentReference;
 
 import java.util.Collections;
@@ -124,10 +124,10 @@ public DataSource withPolicies(Map<String, Optional<Policy>> policyMap)
   }
 
   @Override
-  public boolean validate(PolicyConfig tableSecurityPolicyConfig)
+  public boolean validate(PolicyEnforcer policyEnforcer)
   {
     // If it reaches here, this table is not wrapped with a RestrictedDataSource (which should overwrite this method).
-    return !tableSecurityPolicyConfig.policyMustBeCheckedAndExistOnAllTables();
+    return policyEnforcer.validate(this);
   }
 
   @Override
diff --git a/processing/src/main/java/org/apache/druid/query/policy/NoopPolicyEnforcer.java b/processing/src/main/java/org/apache/druid/query/policy/NoopPolicyEnforcer.java
new file mode 100644
index 000000000000..f82223fc7cfc
--- /dev/null
+++ b/processing/src/main/java/org/apache/druid/query/policy/NoopPolicyEnforcer.java
@@ -0,0 +1,63 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.query.policy;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import org.apache.druid.query.DataSource;
+
+/**
+ * Allows all data sources (no restrictions).
+ */
+public class NoopPolicyEnforcer implements PolicyEnforcer
+{
+  NoopPolicyEnforcer()
+  {
+  }
+
+  @Override
+  public boolean validate(DataSource unused)
+  {
+    return true;
+  }
+
+  @JsonCreator
+  public static NoopPolicyEnforcer instance()
+  {
+    return new NoopPolicyEnforcer();
+  }
+
+  @Override
+  public boolean equals(Object o)
+  {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    return true;
+  }
+
+  @Override
+  public int hashCode()
+  {
+    return 0;
+  }
+}
diff --git a/processing/src/main/java/org/apache/druid/query/policy/PolicyConfig.java b/processing/src/main/java/org/apache/druid/query/policy/PolicyConfig.java
deleted file mode 100644
index 37f8e0d940a2..000000000000
--- a/processing/src/main/java/org/apache/druid/query/policy/PolicyConfig.java
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.apache.druid.query.policy;
-
-import com.fasterxml.jackson.annotation.JsonCreator;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.google.common.collect.ImmutableList;
-
-import javax.annotation.Nonnull;
-import java.util.Objects;
-
-/**
- * Defines how strict we want to enforce the policy on tables during query execution process.
- */
-public class PolicyConfig
-{
-  @JsonProperty
-  private final TablePolicySecurityLevel tablePolicySecurityLevel;
-
-  @JsonProperty
-  private final ImmutableList<String> allowedPolicies;
-
-  @JsonCreator
-  public PolicyConfig(
-      @JsonProperty("tablePolicySecurityLevel") TablePolicySecurityLevel tablePolicySecurityLevel,
-      @JsonProperty("allowedPolicies") ImmutableList<String> allowedPolicies
-  )
-  {
-    this.tablePolicySecurityLevel = tablePolicySecurityLevel;
-    this.allowedPolicies = allowedPolicies;
-  }
-
-  /**
-   * Returns a {@link PolicyConfig} instance that applies restrictions whenever seen fit, and allows all policy types.
-   */
-  public static PolicyConfig defaultInstance()
-  {
-    return new PolicyConfig(TablePolicySecurityLevel.APPLY_WHEN_APPLICABLE, ImmutableList.of());
-  }
-
-  /**
-   * Returns the table policy security level, higher value means stricter policy.
-   *
-   * @see TablePolicySecurityLevel
-   */
-  @JsonProperty
-  public TablePolicySecurityLevel getTablePolicySecurityLevel()
-  {
-    return tablePolicySecurityLevel;
-  }
-
-  /**
-   * Returns a list of allowed policy class.
-   * <p>
-   * An empty list means all policy classes are allowed.
-   */
-  @JsonProperty
-  public ImmutableList<String> getAllowedPolicies()
-  {
-    return allowedPolicies;
-  }
-
-  public boolean allowPolicy(@Nonnull Policy policy)
-  {
-    return allowedPolicies.isEmpty() || allowedPolicies.contains(policy.getClass().getSimpleName());
-  }
-
-  /**
-   * Returns true if the security level requires that, every table must have a policy during query execution stage,
-   * this means the table must have a non-empty value in the policy map.
-   */
-  public boolean policyMustBeCheckedAndExistOnAllTables()
-  {
-    return tablePolicySecurityLevel.securityLevel >= 2.0;
-  }
-
-  @Override
-  public String toString()
-  {
-    return "PolicyConfig{tablePolicySecurityLevel="
-           + tablePolicySecurityLevel
-           + ", allowedPolicies="
-           + allowedPolicies
-           + '}';
-  }
-
-  @Override
-  public boolean equals(Object o)
-  {
-    if (this == o) {
-      return true;
-    }
-    if (o == null || getClass() != o.getClass()) {
-      return false;
-    }
-    PolicyConfig that = (PolicyConfig) o;
-    return Objects.equals(tablePolicySecurityLevel, that.tablePolicySecurityLevel) &&
-           Objects.equals(allowedPolicies, that.allowedPolicies);
-  }
-
-  @Override
-  public int hashCode()
-  {
-    return Objects.hash(tablePolicySecurityLevel, allowedPolicies);
-  }
-
-
-  /**
-   * Defines how strict we want to enforce the policy on tables during query execution process.
-   * <ol>
-   *   <li>{@code APPLY_WHEN_APPLICABLE}, the most basic level, restriction is applied whenever seen fit.
-   *   <li>{@code POLICY_CHECKED_ON_ALL_TABLES_POLICY_MUST_EXIST}, every table must have a policy when requests come from external users.
-   * </ol>
-   */
-  public enum TablePolicySecurityLevel
-  {
-    @JsonProperty("0") APPLY_WHEN_APPLICABLE(0f),
-    @JsonProperty("2.0f") POLICY_CHECKED_ON_ALL_TABLES_POLICY_MUST_EXIST(2.0f);
-
-    private final float securityLevel;
-
-    TablePolicySecurityLevel(float securityLevel)
-    {
-      this.securityLevel = securityLevel;
-    }
-  }
-}
diff --git a/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java b/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
new file mode 100644
index 000000000000..d48942e373ec
--- /dev/null
+++ b/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
@@ -0,0 +1,45 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.query.policy;
+
+import com.fasterxml.jackson.annotation.JsonSubTypes;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import org.apache.druid.guice.annotations.UnstableApi;
+import org.apache.druid.query.DataSource;
+
+/**
+ * A mechanism for enforcing policies on data sources in Druid queries.
+ */
+@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type", defaultImpl = NoopPolicyEnforcer.class)
+@JsonSubTypes({
+    @JsonSubTypes.Type(value = NoopPolicyEnforcer.class, name = "none"),
+    @JsonSubTypes.Type(value = RestrictAllTablesPolicyEnforcer.class, name = "restrictAllTables"),
+})
+@UnstableApi
+public interface PolicyEnforcer
+{
+
+  /**
+   * Validate a data source against the policy enforcer.
+   * @param ds data source to validate
+   * @return true if the data source is valid according to the policy enforcer, false otherwise
+   */
+  boolean validate(DataSource ds);
+}
diff --git a/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java b/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java
new file mode 100644
index 000000000000..77ea064ad6e8
--- /dev/null
+++ b/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java
@@ -0,0 +1,109 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.query.policy;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import org.apache.druid.query.DataSource;
+import org.apache.druid.query.RestrictedDataSource;
+import org.reflections.Reflections;
+
+import javax.annotation.Nullable;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * All tables must be restricted by a policy. 
+ */
+public class RestrictAllTablesPolicyEnforcer implements PolicyEnforcer
+{
+  private final ImmutableList<String> allowedPolicies;
+
+  @JsonCreator
+  public RestrictAllTablesPolicyEnforcer(
+      @Nullable @JsonProperty("allowedPolicies") List<String> allowedPolicies
+  )
+  {
+    if (allowedPolicies == null) {
+      this.allowedPolicies = ImmutableList.of();
+    } else {
+      Set<String> policyClazz = new Reflections("org.apache.druid.query.policy").getSubTypesOf(
+          Policy.class).stream().map(Class::getSimpleName).collect(Collectors.toSet());
+
+      List<String> unrecognizedClazz = allowedPolicies.stream()
+                                                      .filter(p -> !policyClazz.contains(p))
+                                                      .collect(Collectors.toList());
+      Preconditions.checkArgument(
+          unrecognizedClazz.isEmpty(),
+          "Unrecognized policy class[%s], must be one of class[%s]",
+          unrecognizedClazz,
+          policyClazz
+      );
+      this.allowedPolicies = ImmutableList.copyOf(allowedPolicies);
+    }
+  }
+
+  @Override
+  public boolean validate(DataSource ds)
+  {
+    if (ds instanceof RestrictedDataSource) {
+      Policy policy = ((RestrictedDataSource) ds).getPolicy();
+      return allowedPolicies.isEmpty() || allowedPolicies.contains(policy.getClass().getSimpleName());
+    }
+    return false;
+  }
+
+  @JsonProperty
+  public ImmutableList<String> getAllowedPolicies()
+  {
+    return allowedPolicies;
+  }
+
+  @Override
+  public boolean equals(Object o)
+  {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    RestrictAllTablesPolicyEnforcer that = (RestrictAllTablesPolicyEnforcer) o;
+    return allowedPolicies.equals(that.allowedPolicies);
+  }
+
+  @Override
+  public int hashCode()
+  {
+    return Objects.hash(allowedPolicies);
+  }
+
+  @Override
+  public String toString()
+  {
+    return "RestrictAllTablesPolicyEnforcer{" +
+           "allowedPolicies=" + allowedPolicies +
+           '}';
+  }
+}
diff --git a/processing/src/test/java/org/apache/druid/query/DataSourceTest.java b/processing/src/test/java/org/apache/druid/query/DataSourceTest.java
index 0b639befda2f..dd1ec49825ed 100644
--- a/processing/src/test/java/org/apache/druid/query/DataSourceTest.java
+++ b/processing/src/test/java/org/apache/druid/query/DataSourceTest.java
@@ -30,8 +30,9 @@
 import org.apache.druid.query.filter.NullFilter;
 import org.apache.druid.query.groupby.GroupByQuery;
 import org.apache.druid.query.policy.NoRestrictionPolicy;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.policy.Policy;
-import org.apache.druid.query.policy.PolicyConfig;
+import org.apache.druid.query.policy.RestrictAllTablesPolicyEnforcer;
 import org.apache.druid.query.policy.RowFilterPolicy;
 import org.apache.druid.segment.TestHelper;
 import org.junit.Assert;
@@ -231,24 +232,20 @@ public void testValidate_onRestrictedDataSource()
         TableDataSource.create("table1"),
         RowFilterPolicy.from(new NullFilter("random-column", null))
     );
-    Assert.assertTrue(restrictedDataSource.validate(PolicyConfig.defaultInstance()));
+    Assert.assertTrue(restrictedDataSource.validate(NoopPolicyEnforcer.instance()));
+    Assert.assertTrue(restrictedDataSource.validate(new RestrictAllTablesPolicyEnforcer(null)));
     // Fail, only NoRestrictionPolicy is allowed.
-    Assert.assertFalse(restrictedDataSource.validate(new PolicyConfig(
-        PolicyConfig.TablePolicySecurityLevel.POLICY_CHECKED_ON_ALL_TABLES_POLICY_MUST_EXIST,
-        ImmutableList.of(NoRestrictionPolicy.class.getSimpleName())
-    )));
+    Assert.assertFalse(restrictedDataSource.validate(new RestrictAllTablesPolicyEnforcer(ImmutableList.of(
+        "NoRestrictionPolicy"))));
   }
 
   @Test
   public void testValidate_onTableDataSource()
   {
     TableDataSource tableDataSource = TableDataSource.create("table1");
-    Assert.assertTrue(tableDataSource.validate(PolicyConfig.defaultInstance()));
+    Assert.assertTrue(tableDataSource.validate(NoopPolicyEnforcer.instance()));
     // Fail, policy must exist on table
-    Assert.assertFalse(tableDataSource.validate(new PolicyConfig(
-        PolicyConfig.TablePolicySecurityLevel.POLICY_CHECKED_ON_ALL_TABLES_POLICY_MUST_EXIST,
-        ImmutableList.of()
-    )));
+    Assert.assertFalse(tableDataSource.validate(new RestrictAllTablesPolicyEnforcer(null)));
   }
 
   @Test
@@ -259,17 +256,13 @@ public void testValidate_onUnionDataSource()
             TableDataSource.create("table1"),
             RowFilterPolicy.from(new NullFilter("random-column", null))
         ),
-        TableDataSource.create("table2")));
-    Assert.assertTrue(unionDataSource.validate(PolicyConfig.defaultInstance()));
+        TableDataSource.create("table2")
+    ));
+    Assert.assertTrue(unionDataSource.validate(NoopPolicyEnforcer.instance()));
     // Fail, policy must exist on table
-    Assert.assertFalse(unionDataSource.validate(new PolicyConfig(
-        PolicyConfig.TablePolicySecurityLevel.POLICY_CHECKED_ON_ALL_TABLES_POLICY_MUST_EXIST,
-        ImmutableList.of()
-    )));
+    Assert.assertFalse(unionDataSource.validate(new RestrictAllTablesPolicyEnforcer(null)));
     // Fail, only NoRestrictionPolicy is allowed.
-    Assert.assertFalse(unionDataSource.validate(new PolicyConfig(
-        PolicyConfig.TablePolicySecurityLevel.APPLY_WHEN_APPLICABLE,
-        ImmutableList.of(NoRestrictionPolicy.class.getSimpleName())
-    )));
+    Assert.assertFalse(unionDataSource.validate(new RestrictAllTablesPolicyEnforcer(ImmutableList.of(
+        "NoRestrictionPolicy"))));
   }
 }
diff --git a/processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java b/processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java
new file mode 100644
index 000000000000..e7bcd008b713
--- /dev/null
+++ b/processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java
@@ -0,0 +1,66 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.query.policy;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.druid.query.RestrictedDataSource;
+import org.apache.druid.query.TableDataSource;
+import org.apache.druid.query.filter.NullFilter;
+import org.apache.druid.segment.TestHelper;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class NoopPolicyEnforcerTest
+{
+  @Test
+  public void test_serialize() throws Exception
+  {
+    NoopPolicyEnforcer policyEnforcer = NoopPolicyEnforcer.instance();
+    ObjectMapper jsonMapper = TestHelper.makeJsonMapper();
+
+    String expected = "{\"type\":\"none\"}";
+    Assert.assertEquals(expected, jsonMapper.writeValueAsString(policyEnforcer));
+  }
+
+  @Test
+  public void test_serde_roundTrip() throws Exception
+  {
+    NoopPolicyEnforcer policyEnforcer = NoopPolicyEnforcer.instance();
+    ObjectMapper jsonMapper = TestHelper.makeJsonMapper();
+    PolicyEnforcer deserialized = jsonMapper.readValue(
+        jsonMapper.writeValueAsString(policyEnforcer),
+        PolicyEnforcer.class
+    );
+    Assert.assertEquals(policyEnforcer, deserialized);
+  }
+
+  @Test
+  public void test_validate() throws Exception
+  {
+    NoopPolicyEnforcer policyEnforcer = NoopPolicyEnforcer.instance();
+    RowFilterPolicy policy = RowFilterPolicy.from(new NullFilter("some-col", null));
+    TableDataSource table = TableDataSource.create("table");
+    RestrictedDataSource restricted = RestrictedDataSource.create(table, policy);
+
+    Assert.assertTrue(policyEnforcer.validate(table));
+    Assert.assertTrue(policyEnforcer.validate(restricted));
+  }
+
+}
diff --git a/processing/src/test/java/org/apache/druid/query/policy/PolicyConfigTest.java b/processing/src/test/java/org/apache/druid/query/policy/PolicyConfigTest.java
deleted file mode 100644
index 7f7232a9b2a5..000000000000
--- a/processing/src/test/java/org/apache/druid/query/policy/PolicyConfigTest.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.apache.druid.query.policy;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.google.common.collect.ImmutableList;
-import nl.jqno.equalsverifier.EqualsVerifier;
-import org.apache.druid.query.filter.NullFilter;
-import org.apache.druid.segment.TestHelper;
-import org.junit.Assert;
-import org.junit.Test;
-
-public class PolicyConfigTest
-{
-
-  @Test
-  public void test_equals()
-  {
-    EqualsVerifier.forClass(PolicyConfig.class).usingGetClass().verify();
-  }
-
-  @Test
-  public void test_deserialize_fromString() throws Exception
-  {
-    ObjectMapper jsonMapper = TestHelper.makeJsonMapper();
-    PolicyConfig deserialized = jsonMapper.readValue(
-        "{\"tablePolicySecurityLevel\":\"2.0f\",\"allowedPolicies\":[\"NoRestrictionPolicy\",\"RowFilterPolicy\"]}",
-        PolicyConfig.class
-    );
-    Assert.assertEquals(new PolicyConfig(
-        PolicyConfig.TablePolicySecurityLevel.POLICY_CHECKED_ON_ALL_TABLES_POLICY_MUST_EXIST,
-        ImmutableList.of(NoRestrictionPolicy.class.getSimpleName(), RowFilterPolicy.class.getSimpleName())
-    ), deserialized);
-  }
-
-  @Test
-  public void test_serde_roundTrip() throws Exception
-  {
-    final PolicyConfig policyConfig = PolicyConfig.defaultInstance();
-    ObjectMapper jsonMapper = TestHelper.makeJsonMapper();
-    PolicyConfig deserialized = jsonMapper.readValue(jsonMapper.writeValueAsString(policyConfig), PolicyConfig.class);
-    Assert.assertEquals(policyConfig, deserialized);
-  }
-
-  @Test
-  public void test_policyMustBeCheckedAndExistOnAllTables() throws Exception
-  {
-    PolicyConfig defaultConfig = PolicyConfig.defaultInstance();
-    PolicyConfig config = new PolicyConfig(
-        PolicyConfig.TablePolicySecurityLevel.POLICY_CHECKED_ON_ALL_TABLES_POLICY_MUST_EXIST,
-        ImmutableList.of(NoRestrictionPolicy.class.getSimpleName())
-    );
-
-    Assert.assertFalse(defaultConfig.policyMustBeCheckedAndExistOnAllTables());
-    Assert.assertTrue(config.policyMustBeCheckedAndExistOnAllTables());
-  }
-
-  @Test
-  public void test_allowPolicy() throws Exception
-  {
-    PolicyConfig defaultConfig = PolicyConfig.defaultInstance();
-    PolicyConfig config = new PolicyConfig(
-        PolicyConfig.TablePolicySecurityLevel.POLICY_CHECKED_ON_ALL_TABLES_POLICY_MUST_EXIST,
-        ImmutableList.of(NoRestrictionPolicy.class.getSimpleName())
-    );
-    RowFilterPolicy policy = RowFilterPolicy.from(new NullFilter("some-col", null));
-
-    Assert.assertTrue(defaultConfig.allowPolicy(policy));
-    Assert.assertFalse(config.allowPolicy(policy));
-    Assert.assertEquals(ImmutableList.of(NoRestrictionPolicy.class.getSimpleName()), config.getAllowedPolicies());
-    Assert.assertEquals(ImmutableList.of(), defaultConfig.getAllowedPolicies());
-  }
-}
diff --git a/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java b/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
new file mode 100644
index 000000000000..dcaf8b92b090
--- /dev/null
+++ b/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
@@ -0,0 +1,79 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.query.policy;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.collect.ImmutableList;
+import org.apache.druid.query.RestrictedDataSource;
+import org.apache.druid.query.TableDataSource;
+import org.apache.druid.query.filter.NullFilter;
+import org.apache.druid.segment.TestHelper;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class RestrictAllTablesPolicyEnforcerTest
+{
+  @Test
+  public void test_serialize() throws Exception
+  {
+    RestrictAllTablesPolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    ObjectMapper jsonMapper = TestHelper.makeJsonMapper();
+
+    String expected = "{\"type\":\"restrictAllTables\",\"allowedPolicies\":[]}";
+    Assert.assertEquals(expected, jsonMapper.writeValueAsString(policyEnforcer));
+  }
+
+  @Test
+  public void test_serde_roundTrip() throws Exception
+  {
+    RestrictAllTablesPolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    ObjectMapper jsonMapper = TestHelper.makeJsonMapper();
+    PolicyEnforcer deserialized = jsonMapper.readValue(
+        jsonMapper.writeValueAsString(policyEnforcer),
+        PolicyEnforcer.class
+    );
+    Assert.assertEquals(policyEnforcer, deserialized);
+  }
+
+  @Test
+  public void test_validate() throws Exception
+  {
+    RestrictAllTablesPolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    RowFilterPolicy policy = RowFilterPolicy.from(new NullFilter("some-col", null));
+    TableDataSource table = TableDataSource.create("table");
+    RestrictedDataSource restricted = RestrictedDataSource.create(table, policy);
+
+    Assert.assertFalse(policyEnforcer.validate(table));
+    Assert.assertTrue(policyEnforcer.validate(restricted));
+  }
+
+  @Test
+  public void test_validate_withAllowedPolicies() throws Exception
+  {
+    RestrictAllTablesPolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(ImmutableList.of(
+        "NoRestrictionPolicy"));
+    RowFilterPolicy policy = RowFilterPolicy.from(new NullFilter("some-col", null));
+    TableDataSource table = TableDataSource.create("table");
+    RestrictedDataSource restricted = RestrictedDataSource.create(table, policy);
+
+    Assert.assertFalse(policyEnforcer.validate(table));
+    Assert.assertFalse(policyEnforcer.validate(restricted));
+  }
+}
diff --git a/server/src/main/java/org/apache/druid/guice/security/PolicyModule.java b/server/src/main/java/org/apache/druid/guice/security/PolicyModule.java
new file mode 100644
index 000000000000..6ddb332b39e7
--- /dev/null
+++ b/server/src/main/java/org/apache/druid/guice/security/PolicyModule.java
@@ -0,0 +1,37 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.guice.security;
+
+import com.google.inject.Binder;
+import org.apache.druid.guice.JsonConfigProvider;
+import org.apache.druid.initialization.DruidModule;
+import org.apache.druid.query.policy.PolicyEnforcer;
+
+/**
+ * Module for configuring the policy enforcer.
+ */
+public class PolicyModule implements DruidModule
+{
+  @Override
+  public void configure(Binder binder)
+  {
+    JsonConfigProvider.bind(binder, "druid.policy.enforcer", PolicyEnforcer.class);
+  }
+}
diff --git a/server/src/main/java/org/apache/druid/initialization/CoreInjectorBuilder.java b/server/src/main/java/org/apache/druid/initialization/CoreInjectorBuilder.java
index 902d2855a0a5..2e28aaf958bb 100644
--- a/server/src/main/java/org/apache/druid/initialization/CoreInjectorBuilder.java
+++ b/server/src/main/java/org/apache/druid/initialization/CoreInjectorBuilder.java
@@ -46,6 +46,7 @@
 import org.apache.druid.guice.security.AuthorizerModule;
 import org.apache.druid.guice.security.DruidAuthModule;
 import org.apache.druid.guice.security.EscalatorModule;
+import org.apache.druid.guice.security.PolicyModule;
 import org.apache.druid.metadata.storage.derby.DerbyMetadataStorageDruidModule;
 import org.apache.druid.rpc.guice.ServiceClientModule;
 import org.apache.druid.segment.writeout.SegmentWriteOutMediumModule;
@@ -99,6 +100,7 @@ public CoreInjectorBuilder forServer()
     add(
         ExtensionsModule.SecondaryModule.class,
         new DruidAuthModule(),
+        new PolicyModule(),
         TLSCertificateCheckerModule.class,
         EmitterModule.class,
         HttpClientModule.global(),
diff --git a/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java b/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
index bc7f5131a68a..e93f5268834b 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
@@ -55,6 +55,7 @@
 import org.apache.druid.query.SegmentDescriptor;
 import org.apache.druid.query.metadata.metadata.SegmentMetadataQuery;
 import org.apache.druid.query.planning.DataSourceAnalysis;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.query.spec.SpecificSegmentQueryRunner;
 import org.apache.druid.query.spec.SpecificSegmentSpec;
 import org.apache.druid.segment.ReferenceCountingSegment;
@@ -64,7 +65,6 @@
 import org.apache.druid.server.SegmentManager;
 import org.apache.druid.server.SetAndVerifyContextQueryRunner;
 import org.apache.druid.server.initialization.ServerConfig;
-import org.apache.druid.server.security.AuthConfig;
 import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 import org.apache.druid.timeline.partition.PartitionChunk;
@@ -93,7 +93,7 @@ public class ServerManager implements QuerySegmentWalker
   private final CacheConfig cacheConfig;
   private final SegmentManager segmentManager;
   private final ServerConfig serverConfig;
-  private final AuthConfig authConfig;
+  private final PolicyEnforcer policyEnforcer;
 
   @Inject
   public ServerManager(
@@ -106,7 +106,7 @@ public ServerManager(
       CacheConfig cacheConfig,
       SegmentManager segmentManager,
       ServerConfig serverConfig,
-      AuthConfig authConfig
+      PolicyEnforcer policyEnforcer
   )
   {
     this.conglomerate = conglomerate;
@@ -120,7 +120,7 @@ public ServerManager(
     this.cacheConfig = cacheConfig;
     this.segmentManager = segmentManager;
     this.serverConfig = serverConfig;
-    this.authConfig = authConfig;
+    this.policyEnforcer = policyEnforcer;
   }
 
   @Override
@@ -195,8 +195,7 @@ public <T> QueryRunner<T> getQueryRunnerForSegments(Query<T> theQuery, Iterable<
       throw new ISE("Cannot handle subquery: %s", dataSourceFromQuery);
     }
 
-    if (!(theQuery instanceof SegmentMetadataQuery)
-        && !dataSourceFromQuery.validate(authConfig.getTableSecurityPolicyConfig())) {
+    if (!(theQuery instanceof SegmentMetadataQuery) && !policyEnforcer.validate(dataSourceFromQuery)) {
       throw new ISE("Failed security validation with dataSource [%s]", dataSourceFromQuery);
     }
 
diff --git a/server/src/main/java/org/apache/druid/server/security/AuthConfig.java b/server/src/main/java/org/apache/druid/server/security/AuthConfig.java
index 9690b0955cc5..4ad6325d8e45 100644
--- a/server/src/main/java/org/apache/druid/server/security/AuthConfig.java
+++ b/server/src/main/java/org/apache/druid/server/security/AuthConfig.java
@@ -23,7 +23,6 @@
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.collect.ImmutableSet;
 import org.apache.druid.query.QueryContexts;
-import org.apache.druid.query.policy.PolicyConfig;
 import org.apache.druid.utils.CollectionUtils;
 
 import java.util.Collections;
@@ -64,7 +63,7 @@ public class AuthConfig
 
   public AuthConfig()
   {
-    this(null, null, null, false, false, null, null, false, null);
+    this(null, null, null, false, false, null, null, false);
   }
 
   @JsonProperty
@@ -101,9 +100,6 @@ public AuthConfig()
   @JsonProperty
   private final boolean enableInputSourceSecurity;
 
-  @JsonProperty
-  private final PolicyConfig tableSecurityPolicyConfig;
-
   @JsonCreator
   public AuthConfig(
       @JsonProperty("authenticatorChain") List<String> authenticatorChain,
@@ -113,8 +109,7 @@ public AuthConfig(
       @JsonProperty("authorizeQueryContextParams") boolean authorizeQueryContextParams,
       @JsonProperty("unsecuredContextKeys") Set<String> unsecuredContextKeys,
       @JsonProperty("securedContextKeys") Set<String> securedContextKeys,
-      @JsonProperty("enableInputSourceSecurity") boolean enableInputSourceSecurity,
-      @JsonProperty("tableSecurityPolicyConfig") PolicyConfig tableSecurityPolicyConfig
+      @JsonProperty("enableInputSourceSecurity") boolean enableInputSourceSecurity
   )
   {
     this.authenticatorChain = authenticatorChain;
@@ -127,9 +122,6 @@ public AuthConfig(
                                 : unsecuredContextKeys;
     this.securedContextKeys = securedContextKeys;
     this.enableInputSourceSecurity = enableInputSourceSecurity;
-    this.tableSecurityPolicyConfig = tableSecurityPolicyConfig == null
-                                     ? PolicyConfig.defaultInstance()
-                                     : tableSecurityPolicyConfig;
   }
 
   public List<String> getAuthenticatorChain()
@@ -162,11 +154,6 @@ public boolean isEnableInputSourceSecurity()
     return enableInputSourceSecurity;
   }
 
-  public PolicyConfig getTableSecurityPolicyConfig()
-  {
-    return tableSecurityPolicyConfig;
-  }
-
   /**
    * Filter the user-supplied context keys based on the context key security
    * rules. If context key security is disabled, then allow all keys. Else,
@@ -214,8 +201,7 @@ public boolean equals(Object o)
            && Objects.equals(unsecuredPaths, that.unsecuredPaths)
            && Objects.equals(unsecuredContextKeys, that.unsecuredContextKeys)
            && Objects.equals(securedContextKeys, that.securedContextKeys)
-           && Objects.equals(enableInputSourceSecurity, that.enableInputSourceSecurity)
-           && Objects.equals(tableSecurityPolicyConfig, that.tableSecurityPolicyConfig);
+           && Objects.equals(enableInputSourceSecurity, that.enableInputSourceSecurity);
   }
 
   @Override
@@ -229,8 +215,7 @@ public int hashCode()
         authorizeQueryContextParams,
         unsecuredContextKeys,
         securedContextKeys,
-        enableInputSourceSecurity,
-        tableSecurityPolicyConfig
+        enableInputSourceSecurity
     );
   }
 
@@ -246,7 +231,6 @@ public String toString()
            ", unsecuredContextKeys=" + unsecuredContextKeys +
            ", securedContextKeys=" + securedContextKeys +
            ", enableInputSourceSecurity=" + enableInputSourceSecurity +
-           ", tableSecurityPolicyConfig=" + tableSecurityPolicyConfig +
            '}';
   }
 
@@ -268,7 +252,6 @@ public static class Builder
     private Set<String> unsecuredContextKeys;
     private Set<String> securedContextKeys;
     private boolean enableInputSourceSecurity;
-    private PolicyConfig tableSecurityPolicyConfig;
 
     public Builder setAuthenticatorChain(List<String> authenticatorChain)
     {
@@ -318,12 +301,6 @@ public Builder setEnableInputSourceSecurity(boolean enableInputSourceSecurity)
       return this;
     }
 
-    public Builder setTableSecurityPolicyConfig(PolicyConfig tableSecurityPolicyConfig)
-    {
-      this.tableSecurityPolicyConfig = tableSecurityPolicyConfig;
-      return this;
-    }
-
     public AuthConfig build()
     {
       return new AuthConfig(
@@ -334,8 +311,7 @@ public AuthConfig build()
           authorizeQueryContextParams,
           unsecuredContextKeys,
           securedContextKeys,
-          enableInputSourceSecurity,
-          tableSecurityPolicyConfig
+          enableInputSourceSecurity
       );
     }
   }
diff --git a/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java b/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
new file mode 100644
index 000000000000..eb4f702be621
--- /dev/null
+++ b/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
@@ -0,0 +1,109 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.guice.security;
+
+import com.google.common.collect.ImmutableList;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import com.google.inject.Key;
+import com.google.inject.ProvisionException;
+import org.apache.druid.guice.ConfigModule;
+import org.apache.druid.guice.DruidGuiceExtensions;
+import org.apache.druid.jackson.JacksonModule;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
+import org.apache.druid.query.policy.PolicyEnforcer;
+import org.apache.druid.query.policy.RestrictAllTablesPolicyEnforcer;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Properties;
+
+public class PolicyModuleTest
+{
+  @Test
+  public void testDefaultNoopPolicyEnforcer()
+  {
+    Properties properties = new Properties();
+    PolicyEnforcer policyEnforcer = Guice.createInjector(
+        new DruidGuiceExtensions(),
+        new ConfigModule(),
+        new PolicyModule()
+    ).getInstance(Key.get(PolicyEnforcer.class));
+    Assert.assertNotNull(policyEnforcer);
+    Assert.assertTrue(policyEnforcer instanceof NoopPolicyEnforcer);
+  }
+
+  @Test
+  public void testConfigRestrictAllTablesPolicyEnforcer()
+  {
+    Properties properties = new Properties();
+    properties.setProperty("druid.policy.enforcer.type", "restrictAllTables");
+    PolicyEnforcer policyEnforcer = Guice.createInjector(
+        binder -> binder.bind(Properties.class).toInstance(properties),
+        new DruidGuiceExtensions(),
+        new ConfigModule(),
+        new JacksonModule(),
+        new PolicyModule()
+    ).getInstance(Key.get(PolicyEnforcer.class));
+
+    Assert.assertNotNull(policyEnforcer);
+    Assert.assertEquals(new RestrictAllTablesPolicyEnforcer(null), policyEnforcer);
+  }
+
+  @Test
+  public void testConfigRestrictAllTablesPolicyEnforcerWithAllowedPolicies()
+  {
+    Properties properties = new Properties();
+    properties.setProperty("druid.policy.enforcer.type", "restrictAllTables");
+    properties.setProperty("druid.policy.enforcer.allowedPolicies", "[\"NoRestrictionPolicy\"]");
+    PolicyEnforcer policyEnforcer = Guice.createInjector(
+        binder -> binder.bind(Properties.class).toInstance(properties),
+        new DruidGuiceExtensions(),
+        new ConfigModule(),
+        new JacksonModule(),
+        new PolicyModule()
+    ).getInstance(Key.get(PolicyEnforcer.class));
+
+    Assert.assertNotNull(policyEnforcer);
+    Assert.assertEquals(new RestrictAllTablesPolicyEnforcer(ImmutableList.of("NoRestrictionPolicy")), policyEnforcer);
+  }
+
+  @Test
+  public void testConfigRestrictAllTablesPolicyEnforcerThrowWithUnrecognizedPolicyClazz()
+  {
+    Properties properties = new Properties();
+    properties.setProperty("druid.policy.enforcer.type", "restrictAllTables");
+    properties.setProperty("druid.policy.enforcer.allowedPolicies", "[\"UnrecognizedPolicy\"]");
+
+    Injector injector = Guice.createInjector(
+        binder -> binder.bind(Properties.class).toInstance(properties),
+        new DruidGuiceExtensions(),
+        new ConfigModule(),
+        new JacksonModule(),
+        new PolicyModule()
+    );
+
+    ProvisionException e = Assert.assertThrows(
+        ProvisionException.class,
+        () -> injector.getInstance(Key.get(PolicyEnforcer.class))
+    );
+    Assert.assertTrue(e.getCause().getMessage().contains("Unrecognized policy class"));
+  }
+}
diff --git a/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java b/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
index e34b78606ae5..cd2fe2dbd63e 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
@@ -30,7 +30,6 @@
 import org.apache.druid.segment.loading.StorageLocationConfig;
 import org.apache.druid.server.SegmentManager;
 import org.apache.druid.server.coordination.SegmentChangeStatus.State;
-import org.apache.druid.test.utils.TestSegmentCacheManager;
 import org.apache.druid.timeline.DataSegment;
 import org.junit.Assert;
 import org.junit.Before;
diff --git a/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java b/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
index 382c14c2994b..48691f16d1bb 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
@@ -79,7 +79,9 @@
 import org.apache.druid.query.context.ResponseContext;
 import org.apache.druid.query.metadata.metadata.SegmentMetadataQuery;
 import org.apache.druid.query.policy.NoRestrictionPolicy;
-import org.apache.druid.query.policy.PolicyConfig;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
+import org.apache.druid.query.policy.PolicyEnforcer;
+import org.apache.druid.query.policy.RestrictAllTablesPolicyEnforcer;
 import org.apache.druid.query.search.SearchQuery;
 import org.apache.druid.query.search.SearchResultValue;
 import org.apache.druid.query.spec.MultipleSpecificSegmentSpec;
@@ -91,7 +93,6 @@
 import org.apache.druid.server.TestSegmentUtils.SegmentForTesting;
 import org.apache.druid.server.initialization.ServerConfig;
 import org.apache.druid.server.metrics.NoopServiceEmitter;
-import org.apache.druid.server.security.AuthConfig;
 import org.apache.druid.test.utils.TestSegmentCacheManager;
 import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.TimelineObjectHolder;
@@ -139,7 +140,7 @@ public class ServerManagerTest
   @Bind
   private SegmentManager segmentManager;
   @Bind
-  private AuthConfig authConfig;
+  private PolicyEnforcer policyEnforcer;
   @Bind
   private ServerConfig serverConfig;
   @Bind
@@ -186,7 +187,7 @@ public void setUp()
     cache = new LocalCacheProvider().get();
     cacheConfig = new CacheConfig();
     serverConfig = new ServerConfig();
-    authConfig = new AuthConfig();
+    policyEnforcer = NoopPolicyEnforcer.instance();
 
     Guice.createInjector(BoundFieldModule.of(this)).injectMembers(this);
   }
@@ -610,12 +611,7 @@ public void testGetQueryRunnerForSegments_restricted() throws Exception
         SegmentMetadataQuery.class,
         factory
     ));
-    authConfig = AuthConfig.newBuilder()
-                           .setTableSecurityPolicyConfig(new PolicyConfig(
-                               PolicyConfig.TablePolicySecurityLevel.POLICY_CHECKED_ON_ALL_TABLES_POLICY_MUST_EXIST,
-                               ImmutableList.of()
-                           ))
-                           .build();
+    policyEnforcer = new RestrictAllTablesPolicyEnforcer(ImmutableList.of("NoRestrictionPolicy"));
     serverManager = Guice.createInjector(BoundFieldModule.of(this)).getInstance(ServerManager.class);
     Interval interval = Intervals.of("P1d/2011-04-01");
     SearchQuery query = searchQuery("test", interval, Granularities.ALL);

From 7e9aef5f22cf90aeb567854955defc22585b3503 Mon Sep 17 00:00:00 2001
From: Virushade <70288012+GWphua@users.noreply.github.com>
Date: Fri, 28 Feb 2025 11:55:11 +0800
Subject: [PATCH 12/99] Support pushing and streaming task payload for HDFS
 (#17742)

Implement pushTaskPayload/streamTaskPayload as introduced in #14887
for HDFS storage to allow larger mm-less ingestion payloads when using
HDFS as the deep storage location.
---
 distribution/docker/peon.sh                   |  2 +-
 .../storage/hdfs/tasklog/HdfsTaskLogs.java    | 20 +++++++++++++++
 .../common/tasklogs/HdfsTaskLogsTest.java     | 25 ++++++++++++++-----
 3 files changed, 40 insertions(+), 7 deletions(-)

diff --git a/distribution/docker/peon.sh b/distribution/docker/peon.sh
index 8103f475ccb3..3b4dfc4326b9 100755
--- a/distribution/docker/peon.sh
+++ b/distribution/docker/peon.sh
@@ -161,4 +161,4 @@ fi
 # If TASK_JSON is not set, CliPeon will pull the task.json file from deep storage.
 mkdir -p ${TASK_DIR}; [ -n "$TASK_JSON" ] && echo ${TASK_JSON} | base64 -d | gzip -d > ${TASK_DIR}/task.json;
 
-exec bin/run-java ${JAVA_OPTS} -cp $COMMON_CONF_DIR:$SERVICE_CONF_DIR:lib/*: org.apache.druid.cli.Main internal peon $@
+exec bin/run-java ${JAVA_OPTS} -cp $COMMON_CONF_DIR:$SERVICE_CONF_DIR:lib/*: org.apache.druid.cli.Main internal peon --taskId ${TASK_ID} $@
diff --git a/extensions-core/hdfs-storage/src/main/java/org/apache/druid/storage/hdfs/tasklog/HdfsTaskLogs.java b/extensions-core/hdfs-storage/src/main/java/org/apache/druid/storage/hdfs/tasklog/HdfsTaskLogs.java
index f89b0fafde95..535598bc2d70 100644
--- a/extensions-core/hdfs-storage/src/main/java/org/apache/druid/storage/hdfs/tasklog/HdfsTaskLogs.java
+++ b/extensions-core/hdfs-storage/src/main/java/org/apache/druid/storage/hdfs/tasklog/HdfsTaskLogs.java
@@ -207,6 +207,26 @@ public void killOlderThan(long timestamp) throws IOException
       }
     }
   }
+
+  @Override
+  public void pushTaskPayload(String taskId, File taskPayloadFile) throws IOException
+  {
+    final Path path = getTaskPayloadFileFromId(taskId);
+    log.info("Pushing payload for task[%s] to location[%s]", taskId, path);
+    pushTaskFile(path, taskPayloadFile);
+  }
+
+  @Override
+  public Optional<InputStream> streamTaskPayload(String taskId) throws IOException
+  {
+    final Path path = getTaskPayloadFileFromId(taskId);
+    return streamTaskFile(path, 0);
+  }
+
+  private Path getTaskPayloadFileFromId(String taskId)
+  {
+    return new Path(mergePaths(config.getDirectory(), taskId.replace(':', '_') + ".payload.json"));
+  }
 }
 
 
diff --git a/extensions-core/hdfs-storage/src/test/java/org/apache/druid/indexing/common/tasklogs/HdfsTaskLogsTest.java b/extensions-core/hdfs-storage/src/test/java/org/apache/druid/indexing/common/tasklogs/HdfsTaskLogsTest.java
index 9d0273d1a95f..125fbd288721 100644
--- a/extensions-core/hdfs-storage/src/test/java/org/apache/druid/indexing/common/tasklogs/HdfsTaskLogsTest.java
+++ b/extensions-core/hdfs-storage/src/test/java/org/apache/druid/indexing/common/tasklogs/HdfsTaskLogsTest.java
@@ -50,7 +50,7 @@ public void testStream() throws Exception
     final File tmpDir = tempFolder.newFolder();
     final File logDir = new File(tmpDir, "logs");
     final File logFile = new File(tmpDir, "log");
-    Files.write("blah", logFile, StandardCharsets.UTF_8);
+    Files.asCharSink(logFile, StandardCharsets.UTF_8).write("blah");
     final TaskLogs taskLogs = new HdfsTaskLogs(new HdfsTaskLogsConfig(logDir.toString()), new Configuration());
     taskLogs.pushTaskLog("foo", logFile);
 
@@ -69,11 +69,11 @@ public void testOverwrite() throws Exception
     final File logFile = new File(tmpDir, "log");
     final TaskLogs taskLogs = new HdfsTaskLogs(new HdfsTaskLogsConfig(logDir.toString()), new Configuration());
 
-    Files.write("blah", logFile, StandardCharsets.UTF_8);
+    Files.asCharSink(logFile, StandardCharsets.UTF_8).write("blah");
     taskLogs.pushTaskLog("foo", logFile);
     Assert.assertEquals("blah", readLog(taskLogs, "foo", 0));
 
-    Files.write("blah blah", logFile, StandardCharsets.UTF_8);
+    Files.asCharSink(logFile, StandardCharsets.UTF_8).write("blah blah");
     taskLogs.pushTaskLog("foo", logFile);
     Assert.assertEquals("blah blah", readLog(taskLogs, "foo", 0));
   }
@@ -87,7 +87,7 @@ public void test_taskStatus() throws Exception
     final TaskLogs taskLogs = new HdfsTaskLogs(new HdfsTaskLogsConfig(logDir.toString()), new Configuration());
 
 
-    Files.write("{}", statusFile, StandardCharsets.UTF_8);
+    Files.asCharSink(statusFile, StandardCharsets.UTF_8).write("{}");
     taskLogs.pushTaskStatus("id", statusFile);
     Assert.assertEquals(
         "{}",
@@ -95,6 +95,19 @@ public void test_taskStatus() throws Exception
     );
   }
 
+  @Test
+  public void test_taskPayload() throws Exception
+  {
+    final File tmpDir = tempFolder.newFolder();
+    final File logDir = new File(tmpDir, "logs");
+    final File payload = new File(tmpDir, "payload.json");
+    final TaskLogs taskLogs = new HdfsTaskLogs(new HdfsTaskLogsConfig(logDir.toString()), new Configuration());
+
+    Files.asCharSink(payload, StandardCharsets.UTF_8).write("{}");
+    taskLogs.pushTaskPayload("id", payload);
+    Assert.assertEquals("{}", StringUtils.fromUtf8(ByteStreams.toByteArray(taskLogs.streamTaskPayload("id").get())));
+  }
+
   @Test
   public void testKill() throws Exception
   {
@@ -107,7 +120,7 @@ public void testKill() throws Exception
 
     final TaskLogs taskLogs = new HdfsTaskLogs(new HdfsTaskLogsConfig(logDir.toString()), new Configuration());
 
-    Files.write("log1content", logFile, StandardCharsets.UTF_8);
+    Files.asCharSink(logFile, StandardCharsets.UTF_8).write("log1content");
     taskLogs.pushTaskLog("log1", logFile);
     Assert.assertEquals("log1content", readLog(taskLogs, "log1", 0));
 
@@ -118,7 +131,7 @@ public void testKill() throws Exception
     long time = (System.currentTimeMillis() / 1000) * 1000;
     Assert.assertTrue(fs.getFileStatus(new Path(logDirPath, "log1")).getModificationTime() < time);
 
-    Files.write("log2content", logFile, StandardCharsets.UTF_8);
+    Files.asCharSink(logFile, StandardCharsets.UTF_8).write("log2content");
     taskLogs.pushTaskLog("log2", logFile);
     Assert.assertEquals("log2content", readLog(taskLogs, "log2", 0));
     Assert.assertTrue(fs.getFileStatus(new Path(logDirPath, "log2")).getModificationTime() >= time);

From 65755d29d0d615f311ce2e12faeeec544eef9f66 Mon Sep 17 00:00:00 2001
From: Virushade <70288012+GWphua@users.noreply.github.com>
Date: Sun, 2 Mar 2025 11:26:52 +0800
Subject: [PATCH 13/99] Remove usages of deprecated API Files.write() (#17761)

* Add deprecated com.google.common.io.Files#write to forbiddenApis

* Replace deprecated Files.write()
---
 codestyle/druid-forbidden-apis.txt                   |  1 +
 .../indexer/hadoop/DatasourceInputFormatTest.java    |  2 +-
 .../indexing/common/tasklogs/FileTaskLogsTest.java   | 12 ++++++------
 .../druid/server/log/FileRequestLoggerTest.java      |  2 +-
 4 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/codestyle/druid-forbidden-apis.txt b/codestyle/druid-forbidden-apis.txt
index 893b10fd348f..ed78ae9f8ad7 100644
--- a/codestyle/druid-forbidden-apis.txt
+++ b/codestyle/druid-forbidden-apis.txt
@@ -25,6 +25,7 @@ com.google.common.collect.Sets#newLinkedHashSet() @ Create java.util.LinkedHashS
 com.google.common.collect.Sets#newTreeSet() @ Create java.util.TreeSet directly
 com.google.common.collect.Sets#newTreeSet(java.util.Comparator) @ Create java.util.TreeSet directly
 com.google.common.io.Files#createTempDir() @ Use org.apache.druid.java.util.common.FileUtils.createTempDir()
+com.google.common.io.Files#write(java.lang.CharSequence, java.io.File, java.nio.charset.Charset) @ Use com.google.common.io.Files.asCharSink(to, charset).write(from) instead.
 java.io.File#mkdirs() @ Use org.apache.druid.java.util.common.FileUtils.mkdirp instead
 java.io.File#toURL() @ Use java.io.File#toURI() and java.net.URI#toURL() instead
 java.lang.String#matches(java.lang.String) @ Use startsWith(), endsWith(), contains(), or compile and cache a Pattern explicitly
diff --git a/indexing-hadoop/src/test/java/org/apache/druid/indexer/hadoop/DatasourceInputFormatTest.java b/indexing-hadoop/src/test/java/org/apache/druid/indexer/hadoop/DatasourceInputFormatTest.java
index 562ba7f19abc..fe92a7fa569b 100644
--- a/indexing-hadoop/src/test/java/org/apache/druid/indexer/hadoop/DatasourceInputFormatTest.java
+++ b/indexing-hadoop/src/test/java/org/apache/druid/indexer/hadoop/DatasourceInputFormatTest.java
@@ -357,7 +357,7 @@ public void testGetSplitsUsingDefaultSupplier() throws Exception
   {
     // Use the builtin supplier, reading from the local filesystem, rather than testFormatter.
     final File tmpFile = temporaryFolder.newFile("something:with:colons");
-    Files.write("dummy", tmpFile, StandardCharsets.UTF_8);
+    Files.asCharSink(tmpFile, StandardCharsets.UTF_8).write("dummy");
 
     final ImmutableList<WindowedDataSegment> mySegments = ImmutableList.of(
         WindowedDataSegment.of(
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/common/tasklogs/FileTaskLogsTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/common/tasklogs/FileTaskLogsTest.java
index 046d666b2a3e..20e809b0334b 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/common/tasklogs/FileTaskLogsTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/common/tasklogs/FileTaskLogsTest.java
@@ -58,7 +58,7 @@ public void testSimple() throws Exception
     try {
       final File logDir = new File(tmpDir, "druid/logs");
       final File logFile = new File(tmpDir, "log");
-      Files.write("blah", logFile, StandardCharsets.UTF_8);
+      Files.asCharSink(logFile, StandardCharsets.UTF_8).write("blah");
       final TaskLogs taskLogs = new FileTaskLogs(new FileTaskLogsConfig(logDir));
       taskLogs.pushTaskLog("foo", logFile);
 
@@ -85,7 +85,7 @@ public void testSimpleReport() throws Exception
     final String taskId = "myTask";
     final TestTaskReport testReport = new TestTaskReport(taskId);
     final String testReportString = mapper.writeValueAsString(TaskReport.buildTaskReports(testReport));
-    Files.write(testReportString, reportFile, StandardCharsets.UTF_8);
+    Files.asCharSink(reportFile, StandardCharsets.UTF_8).write(testReportString);
 
     final TaskLogs taskLogs = new FileTaskLogs(new FileTaskLogsConfig(logDir));
     taskLogs.pushTaskReports("foo", reportFile);
@@ -107,7 +107,7 @@ public void testSimpleStatus() throws Exception
     final String taskId = "myTask";
     final TaskStatus taskStatus = TaskStatus.success(taskId);
     final String taskStatusString = mapper.writeValueAsString(taskStatus);
-    Files.write(taskStatusString, statusFile, StandardCharsets.UTF_8);
+    Files.asCharSink(statusFile, StandardCharsets.UTF_8).write(taskStatusString);
 
     final TaskLogs taskLogs = new FileTaskLogs(new FileTaskLogsConfig(logDir));
     taskLogs.pushTaskStatus(taskId, statusFile);
@@ -124,7 +124,7 @@ public void testPushTaskLogDirCreationFails() throws Exception
     final File tmpDir = temporaryFolder.newFolder();
     final File logDir = new File(tmpDir, "druid/logs");
     final File logFile = new File(tmpDir, "log");
-    Files.write("blah", logFile, StandardCharsets.UTF_8);
+    Files.asCharSink(logFile, StandardCharsets.UTF_8).write("blah");
 
     if (!tmpDir.setWritable(false)) {
       throw new RuntimeException("failed to make tmp dir read-only");
@@ -145,7 +145,7 @@ public void testKill() throws Exception
     final File logFile = new File(tmpDir, "log");
     final TaskLogs taskLogs = new FileTaskLogs(new FileTaskLogsConfig(logDir));
 
-    Files.write("log1content", logFile, StandardCharsets.UTF_8);
+    Files.asCharSink(logFile, StandardCharsets.UTF_8).write("log1content");
     taskLogs.pushTaskLog("log1", logFile);
     Assert.assertEquals("log1content", readLog(taskLogs, "log1", 0));
 
@@ -156,7 +156,7 @@ public void testKill() throws Exception
     long time = (System.currentTimeMillis() / 1000) * 1000;
     Assert.assertTrue(new File(logDir, "log1.log").lastModified() < time);
 
-    Files.write("log2content", logFile, StandardCharsets.UTF_8);
+    Files.asCharSink(logFile, StandardCharsets.UTF_8).write("log2content");
     taskLogs.pushTaskLog("log2", logFile);
     Assert.assertEquals("log2content", readLog(taskLogs, "log2", 0));
     Assert.assertTrue(new File(logDir, "log2.log").lastModified() >= time);
diff --git a/server/src/test/java/org/apache/druid/server/log/FileRequestLoggerTest.java b/server/src/test/java/org/apache/druid/server/log/FileRequestLoggerTest.java
index d0668d7df02b..abbb7b956006 100644
--- a/server/src/test/java/org/apache/druid/server/log/FileRequestLoggerTest.java
+++ b/server/src/test/java/org/apache/druid/server/log/FileRequestLoggerTest.java
@@ -94,7 +94,7 @@ public void testLogRemove() throws Exception
     String logString = dateTime + "\t" + HOST + "\t" + "logString";
 
     File oldLogFile = new File(logDir, "2000-01-01.log");
-    com.google.common.io.Files.write("testOldLogContent", oldLogFile, StandardCharsets.UTF_8);
+    com.google.common.io.Files.asCharSink(oldLogFile, StandardCharsets.UTF_8).write("testOldLogContent");
     oldLogFile.setLastModified(new Date(0).getTime());
     FileRequestLogger fileRequestLogger = new FileRequestLogger(
         objectMapper,

From 4da2b337a1287b6dab042f0606e6849b49bfd6b7 Mon Sep 17 00:00:00 2001
From: Eyal Yurman <eyal.yurman@gmail.com>
Date: Mon, 3 Mar 2025 00:40:43 -0800
Subject: [PATCH 14/99] Doc: Fix description typo for sqlserver metadata store
 (#17771)

Mistakenly categories under deep storage instead of metadata store.
---
 docs/configuration/extensions.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/configuration/extensions.md b/docs/configuration/extensions.md
index 821756f7eb2d..7d06d59acd43 100644
--- a/docs/configuration/extensions.md
+++ b/docs/configuration/extensions.md
@@ -89,7 +89,7 @@ All of these community extensions can be downloaded using [pull-deps](../operati
 |druid-iceberg-extensions|Support for ingesting Iceberg tables.|[link](../development/extensions-contrib/iceberg.md)|
 |druid-redis-cache|A cache implementation for Druid based on Redis.|[link](../development/extensions-contrib/redis-cache.md)|
 |druid-time-min-max|Min/Max aggregator for timestamp.|[link](../development/extensions-contrib/time-min-max.md)|
-|sqlserver-metadata-storage|Microsoft SQLServer deep storage.|[link](../development/extensions-contrib/sqlserver.md)|
+|sqlserver-metadata-storage|Microsoft SQLServer metadata store.|[link](../development/extensions-contrib/sqlserver.md)|
 |graphite-emitter|Graphite metrics emitter|[link](../development/extensions-contrib/graphite.md)|
 |statsd-emitter|StatsD metrics emitter|[link](../development/extensions-contrib/statsd.md)|
 |kafka-emitter|Kafka metrics emitter|[link](../development/extensions-contrib/kafka-emitter.md)|

From f0468cd4bbdacd9e474d50bf785d4772d176dbbb Mon Sep 17 00:00:00 2001
From: Kashif Faraz <kashif.faraz@gmail.com>
Date: Mon, 3 Mar 2025 17:28:16 +0530
Subject: [PATCH 15/99] Fix binding of segment metadata cache on CliOverlord
 (#17772)

Changes
---------
- Bind `SegmentMetadataCache` only once to
`HeapMemorySegmentMetadataCache` in `SQLMetadataStorageDruidModule`
- Invoke start and stop of the cache from `DruidOverlord` rather than on lifecycle start/stop
- Do not override the binding in `CliOverlord`
---
 .../mysql/MySQLMetadataStorageModuleTest.java |  8 ++++
 .../indexing/overlord/DruidOverlord.java      |  4 ++
 .../guice/SQLMetadataStorageDruidModule.java  |  8 ++--
 .../cache/HeapMemorySegmentMetadataCache.java |  4 --
 .../org/apache/druid/cli/CliOverlord.java     |  7 ---
 .../org/apache/druid/cli/CliOverlordTest.java | 44 +++++++++++++++++++
 6 files changed, 60 insertions(+), 15 deletions(-)
 create mode 100644 services/src/test/java/org/apache/druid/cli/CliOverlordTest.java

diff --git a/extensions-core/mysql-metadata-storage/src/test/java/org/apache/druid/metadata/storage/mysql/MySQLMetadataStorageModuleTest.java b/extensions-core/mysql-metadata-storage/src/test/java/org/apache/druid/metadata/storage/mysql/MySQLMetadataStorageModuleTest.java
index fee116bfa3a0..cbc3e3ff65e2 100644
--- a/extensions-core/mysql-metadata-storage/src/test/java/org/apache/druid/metadata/storage/mysql/MySQLMetadataStorageModuleTest.java
+++ b/extensions-core/mysql-metadata-storage/src/test/java/org/apache/druid/metadata/storage/mysql/MySQLMetadataStorageModuleTest.java
@@ -35,6 +35,7 @@
 import org.apache.druid.guice.MetadataConfigModule;
 import org.apache.druid.guice.annotations.Json;
 import org.apache.druid.guice.security.EscalatorModule;
+import org.apache.druid.java.util.common.concurrent.ScheduledExecutorFactory;
 import org.apache.druid.java.util.emitter.core.NoopEmitter;
 import org.apache.druid.java.util.emitter.service.ServiceEmitter;
 import org.junit.Assert;
@@ -139,6 +140,13 @@ public DruidLeaderSelector getLeaderSelector()
                 // A provider for DruidLeaderSelector is needed by SqlSegmentMetadataTransactionFactory
                 return null;
               }
+
+              @Provides
+              public ScheduledExecutorFactory getExecutorFactory()
+              {
+                // Required for HeapMemorySegmentMetadataCache
+                return null;
+              }
             }
         )
     );
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/DruidOverlord.java b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/DruidOverlord.java
index f03b2fd48b8e..9aacf6dea844 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/DruidOverlord.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/DruidOverlord.java
@@ -59,6 +59,7 @@ public class DruidOverlord
 
   private final DruidLeaderSelector overlordLeaderSelector;
   private final DruidLeaderSelector.Listener leadershipListener;
+  private final SegmentMetadataCache segmentMetadataCache;
 
   private final ReentrantLock giant = new ReentrantLock(true);
 
@@ -98,6 +99,7 @@ public DruidOverlord(
   )
   {
     this.overlordLeaderSelector = overlordLeaderSelector;
+    this.segmentMetadataCache = segmentMetadataCache;
 
     final DruidNode node = coordinatorOverlordServiceConfig.getOverlordService() == null ? selfNode :
                            selfNode.withService(coordinatorOverlordServiceConfig.getOverlordService());
@@ -225,6 +227,7 @@ public void start()
     giant.lock();
 
     try {
+      segmentMetadataCache.start();
       overlordLeaderSelector.registerListener(leadershipListener);
     }
     finally {
@@ -244,6 +247,7 @@ public void stop()
     try {
       gracefulStopLeaderLifecycle();
       overlordLeaderSelector.unregisterListener();
+      segmentMetadataCache.stop();
     }
     finally {
       giant.unlock();
diff --git a/server/src/main/java/org/apache/druid/guice/SQLMetadataStorageDruidModule.java b/server/src/main/java/org/apache/druid/guice/SQLMetadataStorageDruidModule.java
index e5dabdb8fe4b..7cb48c694ef2 100644
--- a/server/src/main/java/org/apache/druid/guice/SQLMetadataStorageDruidModule.java
+++ b/server/src/main/java/org/apache/druid/guice/SQLMetadataStorageDruidModule.java
@@ -41,7 +41,7 @@
 import org.apache.druid.metadata.SqlSegmentsMetadataManagerProvider;
 import org.apache.druid.metadata.segment.SegmentMetadataTransactionFactory;
 import org.apache.druid.metadata.segment.SqlSegmentMetadataTransactionFactory;
-import org.apache.druid.metadata.segment.cache.NoopSegmentMetadataCache;
+import org.apache.druid.metadata.segment.cache.HeapMemorySegmentMetadataCache;
 import org.apache.druid.metadata.segment.cache.SegmentMetadataCache;
 import org.apache.druid.server.audit.AuditManagerConfig;
 import org.apache.druid.server.audit.AuditSerdeHelper;
@@ -105,10 +105,10 @@ public void configure(Binder binder)
             .to(SQLMetadataRuleManagerProvider.class)
             .in(LazySingleton.class);
 
-    // SegmentMetadataCache is used only by the Overlord
-    // Bind to noop implementation here to fulfill dependencies
+    // SegmentMetadataCache is bound for all services but is used only by the Overlord
+    // Similar to some other classes bound here, such as IndexerSQLMetadataStorageCoordinator
     binder.bind(SegmentMetadataCache.class)
-          .to(NoopSegmentMetadataCache.class)
+          .to(HeapMemorySegmentMetadataCache.class)
           .in(LazySingleton.class);
 
     PolyBind.optionBinder(binder, Key.get(SegmentMetadataTransactionFactory.class))
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCache.java b/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCache.java
index 4a451d162e68..65482e41046b 100644
--- a/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCache.java
+++ b/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCache.java
@@ -35,8 +35,6 @@
 import org.apache.druid.java.util.common.Stopwatch;
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.java.util.common.concurrent.ScheduledExecutorFactory;
-import org.apache.druid.java.util.common.lifecycle.LifecycleStart;
-import org.apache.druid.java.util.common.lifecycle.LifecycleStop;
 import org.apache.druid.java.util.common.parsers.CloseableIterator;
 import org.apache.druid.java.util.emitter.EmittingLogger;
 import org.apache.druid.java.util.emitter.service.ServiceEmitter;
@@ -135,7 +133,6 @@ public HeapMemorySegmentMetadataCache(
 
 
   @Override
-  @LifecycleStart
   public void start()
   {
     if (!isCacheEnabled) {
@@ -152,7 +149,6 @@ public void start()
   }
 
   @Override
-  @LifecycleStop
   public void stop()
   {
     synchronized (cacheStateLock) {
diff --git a/services/src/main/java/org/apache/druid/cli/CliOverlord.java b/services/src/main/java/org/apache/druid/cli/CliOverlord.java
index 7abe1ec55ca4..e73d87d8bfe4 100644
--- a/services/src/main/java/org/apache/druid/cli/CliOverlord.java
+++ b/services/src/main/java/org/apache/druid/cli/CliOverlord.java
@@ -111,8 +111,6 @@
 import org.apache.druid.metadata.SegmentsMetadataManager;
 import org.apache.druid.metadata.SegmentsMetadataManagerProvider;
 import org.apache.druid.metadata.input.InputSourceModule;
-import org.apache.druid.metadata.segment.cache.HeapMemorySegmentMetadataCache;
-import org.apache.druid.metadata.segment.cache.SegmentMetadataCache;
 import org.apache.druid.query.lookup.LookupSerdeModule;
 import org.apache.druid.segment.incremental.RowIngestionMetersFactory;
 import org.apache.druid.segment.metadata.CentralizedDatasourceSchemaConfig;
@@ -231,11 +229,6 @@ public void configure(Binder binder)
             JsonConfigProvider.bind(binder, "druid.indexer.task.default", DefaultTaskConfig.class);
             binder.bind(RetryPolicyFactory.class).in(LazySingleton.class);
 
-            // Override the default binding of SegmentMetadataCache done in SQLMetadataStorageDruidModule
-            binder.bind(SegmentMetadataCache.class)
-                  .to(HeapMemorySegmentMetadataCache.class)
-                  .in(ManageLifecycle.class);
-
             binder.bind(DruidOverlord.class).in(ManageLifecycle.class);
             binder.bind(TaskMaster.class).in(ManageLifecycle.class);
             binder.bind(TaskCountStatsProvider.class).to(TaskMaster.class);
diff --git a/services/src/test/java/org/apache/druid/cli/CliOverlordTest.java b/services/src/test/java/org/apache/druid/cli/CliOverlordTest.java
new file mode 100644
index 000000000000..23efafe89f89
--- /dev/null
+++ b/services/src/test/java/org/apache/druid/cli/CliOverlordTest.java
@@ -0,0 +1,44 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.cli;
+
+import com.google.inject.Injector;
+import org.apache.druid.guice.StartupInjectorBuilder;
+import org.apache.druid.metadata.segment.cache.HeapMemorySegmentMetadataCache;
+import org.apache.druid.metadata.segment.cache.SegmentMetadataCache;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CliOverlordTest
+{
+  @Test
+  public void testSegmentMetadataCacheIsBound()
+  {
+    final Injector injector = new StartupInjectorBuilder().forServer().build();
+    final CliOverlord overlord = new CliOverlord();
+    injector.injectMembers(overlord);
+
+    final Injector overlordInjector = overlord.makeInjector();
+
+    final SegmentMetadataCache segmentMetadataCache
+        = overlordInjector.getInstance(SegmentMetadataCache.class);
+    Assert.assertTrue(segmentMetadataCache instanceof HeapMemorySegmentMetadataCache);
+  }
+}

From dc2780aa76214c4011741323adbeceaf0501b8e3 Mon Sep 17 00:00:00 2001
From: Frank Chen <frank.chen021@outlook.com>
Date: Tue, 4 Mar 2025 00:25:38 +0800
Subject: [PATCH 16/99] Docs: Remove semicolon from example (#17759)

---
 docs/operations/segment-optimization.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/operations/segment-optimization.md b/docs/operations/segment-optimization.md
index 03c6889c40c0..79dbf9db6b18 100644
--- a/docs/operations/segment-optimization.md
+++ b/docs/operations/segment-optimization.md
@@ -83,7 +83,7 @@ WHERE
   datasource = 'your_dataSource' AND
   is_published = 1
 GROUP BY 1, 2, 3
-ORDER BY 1, 2, 3 DESC;
+ORDER BY 1, 2, 3 DESC
 ```
 
 Please note that the query result might include overshadowed segments.

From b1fcf952976e8f6e145f5678e358dbc82a6d96fc Mon Sep 17 00:00:00 2001
From: Chetan Patidar <122344823+chetanpatidar26@users.noreply.github.com>
Date: Tue, 4 Mar 2025 13:42:58 +0530
Subject: [PATCH 17/99] Restrict segment metadata kill query till maxInterval
 from last kill task time (#17770)

Changes
---------
- Use `maxIntervalToKill` to determine search interval for killing unused segments.
- If no segment has been killed for the datasource yet, use durationToRetain
---
 .../coordinator/duty/KillUnusedSegments.java  | 18 +++++--
 .../duty/KillUnusedSegmentsTest.java          | 50 +++++++++++++++++++
 2 files changed, 65 insertions(+), 3 deletions(-)

diff --git a/server/src/main/java/org/apache/druid/server/coordinator/duty/KillUnusedSegments.java b/server/src/main/java/org/apache/druid/server/coordinator/duty/KillUnusedSegments.java
index 4538d39de957..cd1c17469124 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/duty/KillUnusedSegments.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/duty/KillUnusedSegments.java
@@ -273,9 +273,21 @@ private Interval findIntervalForKill(
   )
   {
     final DateTime minStartTime = datasourceToLastKillIntervalEnd.get(dataSource);
-    final DateTime maxEndTime = ignoreDurationToRetain
-                                ? DateTimes.COMPARE_DATE_AS_STRING_MAX
-                                : DateTimes.nowUtc().minus(durationToRetain);
+
+    // Once the first segment from a datasource is killed, we have a valid minStartTime.
+    // Restricting the upper bound to scan segments metadata while running the kill task results in a efficient SQL query.
+    final DateTime maxEndTime;
+    if (ignoreDurationToRetain) {
+      maxEndTime = DateTimes.COMPARE_DATE_AS_STRING_MAX;
+    } else if (minStartTime == null) {
+      maxEndTime = DateTimes.nowUtc().minus(durationToRetain);
+    } else {
+      // If we have already killed a segment, limit the kill interval based on the minStartTime
+      maxEndTime = DateTimes.min(
+              DateTimes.nowUtc().minus(durationToRetain),
+              minStartTime.plus(maxIntervalToKill)
+      );
+    }
 
     final List<Interval> unusedSegmentIntervals = limitToPeriod(
         segmentsMetadataManager.getUnusedSegmentIntervals(
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/duty/KillUnusedSegmentsTest.java b/server/src/test/java/org/apache/druid/server/coordinator/duty/KillUnusedSegmentsTest.java
index 59df67e4b49c..272ed1887ce7 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/duty/KillUnusedSegmentsTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/duty/KillUnusedSegmentsTest.java
@@ -78,6 +78,7 @@ public class KillUnusedSegmentsTest
   private static final DateTime NOW = DateTimes.nowUtc();
   private static final Interval YEAR_OLD = new Interval(Period.days(1), NOW.minusDays(365));
   private static final Interval MONTH_OLD = new Interval(Period.days(1), NOW.minusDays(30));
+  private static final Interval FIFTEEN_DAY_OLD = new Interval(Period.days(1), NOW.minusDays(15));
   private static final Interval DAY_OLD = new Interval(Period.days(1), NOW.minusDays(1));
   private static final Interval HOUR_OLD = new Interval(Period.days(1), NOW.minusHours(1));
   private static final Interval NEXT_DAY = new Interval(Period.days(1), NOW.plusDays(1));
@@ -604,6 +605,55 @@ public void testLowerMaxIntervalToKill()
     validateLastKillStateAndReset(DS1, YEAR_OLD);
   }
 
+  @Test
+  public void testMaxIntervalToKillOverridesDurationToRetain()
+  {
+    configBuilder.withDurationToRetain(Period.hours(6).toStandardDuration())
+            .withMaxIntervalToKill(Period.days(20));
+
+    initDuty();
+
+    createAndAddUnusedSegment(DS1, MONTH_OLD, VERSION, NOW.minusDays(29));
+    CoordinatorRunStats newDatasourceStats = runDutyAndGetStats();
+
+    // For a new datasource, the duration to retain is used to determine kill interval
+    Assert.assertEquals(1, newDatasourceStats.get(Stats.Kill.ELIGIBLE_UNUSED_SEGMENTS, DS1_STAT_KEY));
+    validateLastKillStateAndReset(DS1, MONTH_OLD);
+
+    // For a datasource where kill has already happened, maxIntervalToKill is used
+    // if it leads to a smaller kill interval than durationToRetain
+    createAndAddUnusedSegment(DS1, FIFTEEN_DAY_OLD, VERSION, NOW.minusDays(14));
+    createAndAddUnusedSegment(DS1, DAY_OLD, VERSION, NOW.minusHours(2));
+    CoordinatorRunStats oldDatasourceStats = runDutyAndGetStats();
+
+    Assert.assertEquals(2, oldDatasourceStats.get(Stats.Kill.ELIGIBLE_UNUSED_SEGMENTS, DS1_STAT_KEY));
+    validateLastKillStateAndReset(DS1, FIFTEEN_DAY_OLD);
+  }
+
+  @Test
+  public void testDurationToRetainOverridesMaxIntervalToKill()
+  {
+    configBuilder.withDurationToRetain(Period.days(20).toStandardDuration())
+            .withMaxIntervalToKill(Period.days(350));
+
+    initDuty();
+
+    createAndAddUnusedSegment(DS1, YEAR_OLD, VERSION, NOW.minusDays(29));
+    CoordinatorRunStats newDatasourceStats = runDutyAndGetStats();
+
+    Assert.assertEquals(1, newDatasourceStats.get(Stats.Kill.ELIGIBLE_UNUSED_SEGMENTS, DS1_STAT_KEY));
+    validateLastKillStateAndReset(DS1, YEAR_OLD);
+
+    // For a datasource where (now - durationToRetain) < (lastKillTime(year old segment) + maxInterval)
+    // Fifteen day old segment will be rejected
+    createAndAddUnusedSegment(DS1, MONTH_OLD, VERSION, NOW.minusDays(29));
+    createAndAddUnusedSegment(DS1, FIFTEEN_DAY_OLD, VERSION, NOW.minusDays(14));
+    CoordinatorRunStats oldDatasourceStats = runDutyAndGetStats();
+
+    Assert.assertEquals(2, oldDatasourceStats.get(Stats.Kill.ELIGIBLE_UNUSED_SEGMENTS, DS1_STAT_KEY));
+    validateLastKillStateAndReset(DS1, MONTH_OLD);
+  }
+
   @Test
   public void testHigherMaxIntervalToKill()
   {

From c3f665d1d4c8aeaf34afc30ef307447c47a4f0c3 Mon Sep 17 00:00:00 2001
From: aho135 <ash023@ucsd.edu>
Date: Tue, 4 Mar 2025 19:33:18 -0800
Subject: [PATCH 18/99] Update the Supervisor endpoint to not restart the
 Supervisor if the spec was unmodified (#17707)

Add an optional query parameter called skipRestartIfUnmodified to the
/druid/indexer/v1/supervisor endpoint. Callers can set skipRestartIfUnmodified=true
to not restart the supervisor if the spec is unchanged.

Example:

curl -X POST --header "Content-Type: application/json" -d @supervisor.json
localhost:8888/druid/indexer/v1/supervisor?skipRestartIfUnmodified=true
---
 docs/api-reference/supervisor-api.md          | 58 +++++++++++++++
 .../supervisor/SupervisorManager.java         | 54 ++++++++++++--
 .../supervisor/SupervisorResource.java        |  9 ++-
 .../supervisor/SupervisorManagerTest.java     | 36 +++++++---
 .../supervisor/SupervisorResourceTest.java    | 71 +++++++++++++++++--
 .../SeekableStreamIndexTaskTestBase.java      |  2 +-
 .../metadata/SQLMetadataRuleManager.java      |  4 ++
 .../metadata/SQLMetadataRuleManagerTest.java  | 46 ++++++++++++
 8 files changed, 259 insertions(+), 21 deletions(-)

diff --git a/docs/api-reference/supervisor-api.md b/docs/api-reference/supervisor-api.md
index 16afdd924f0b..e43470f0e541 100644
--- a/docs/api-reference/supervisor-api.md
+++ b/docs/api-reference/supervisor-api.md
@@ -2353,6 +2353,64 @@ Content-Length: 1359
 </TabItem>
 </Tabs>
 
+#### Sample request with `skipRestartIfUnmodified`
+
+The following example sets the `skipRestartIfUnmodified` flag to true. With this flag set to true, the Supervisor will only restart if there has been a modification to the SupervisorSpec. If left unset, the flag defaults to false.
+```shell
+curl "http://ROUTER_IP:ROUTER_PORT/druid/indexer/v1/supervisor?skipRestartIfUnmodified=true" \
+--header 'Content-Type: application/json' \
+--data '{
+    "type": "kafka",
+    "spec": {
+        "ioConfig": {
+            "type": "kafka",
+            "consumerProperties": {
+                "bootstrap.servers": "localhost:9094"
+            },
+            "topic": "social_media",
+            "inputFormat": {
+                "type": "json"
+            },
+            "useEarliestOffset": true
+        },
+        "tuningConfig": {
+            "type": "kafka"
+        },
+        "dataSchema": {
+            "dataSource": "social_media",
+            "timestampSpec": {
+                "column": "__time",
+                "format": "iso"
+            },
+            "dimensionsSpec": {
+                "dimensions": [
+                    "username",
+                    "post_title",
+                    {
+                        "type": "long",
+                        "name": "views"
+                    },
+                    {
+                        "type": "long",
+                        "name": "upvotes"
+                    },
+                    {
+                        "type": "long",
+                        "name": "comments"
+                    },
+                    "edited"
+                ]
+            },
+            "granularitySpec": {
+                "queryGranularity": "none",
+                "rollup": false,
+                "segmentGranularity": "hour"
+            }
+        }
+    }
+}'
+```
+
 #### Sample response
 
 <details>
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/supervisor/SupervisorManager.java b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/supervisor/SupervisorManager.java
index 731ddcaa1362..85b6d392550e 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/supervisor/SupervisorManager.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/supervisor/SupervisorManager.java
@@ -19,12 +19,15 @@
 
 package org.apache.druid.indexing.overlord.supervisor;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.inject.Inject;
 import org.apache.druid.common.guava.FutureUtils;
 import org.apache.druid.error.DruidException;
+import org.apache.druid.guice.annotations.Json;
 import org.apache.druid.indexing.common.TaskLockType;
 import org.apache.druid.indexing.common.task.Tasks;
 import org.apache.druid.indexing.overlord.DataSourceMetadata;
@@ -42,6 +45,7 @@
 
 import javax.annotation.Nullable;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -62,10 +66,12 @@ public class SupervisorManager
   private final Object lock = new Object();
 
   private volatile boolean started = false;
+  private final ObjectMapper jsonMapper;
 
   @Inject
-  public SupervisorManager(MetadataSupervisorManager metadataSupervisorManager)
+  public SupervisorManager(@Json ObjectMapper jsonMapper, MetadataSupervisorManager metadataSupervisorManager)
   {
+    this.jsonMapper = jsonMapper;
     this.metadataSupervisorManager = metadataSupervisorManager;
   }
 
@@ -152,6 +158,12 @@ public boolean handoffTaskGroupsEarly(String id, List<Integer> taskGroupIds)
     return true;
   }
 
+  /**
+   * Creates or updates a supervisor and then starts it.
+   * If no change has been made to the supervisor spec, it is only restarted.
+   *
+   * @return true if the supervisor was updated, false otherwise
+   */
   public boolean createOrUpdateAndStartSupervisor(SupervisorSpec spec)
   {
     Preconditions.checkState(started, "SupervisorManager not started");
@@ -161,11 +173,40 @@ public boolean createOrUpdateAndStartSupervisor(SupervisorSpec spec)
 
     synchronized (lock) {
       Preconditions.checkState(started, "SupervisorManager not started");
+      final boolean shouldUpdateSpec = shouldUpdateSupervisor(spec);
       possiblyStopAndRemoveSupervisorInternal(spec.getId(), false);
-      return createAndStartSupervisorInternal(spec, true);
+      createAndStartSupervisorInternal(spec, shouldUpdateSpec);
+      return shouldUpdateSpec;
     }
   }
 
+  /**
+   * Checks whether the submitted SupervisorSpec differs from the current spec in SupervisorManager's supervisor list.
+   * This is used in SupervisorResource specPost to determine whether the Supervisor needs to be restarted
+   * @param spec The spec submitted
+   * @return boolean - true only if the spec has been modified, false otherwise
+   */
+  public boolean shouldUpdateSupervisor(SupervisorSpec spec)
+  {
+    Preconditions.checkState(started, "SupervisorManager not started");
+    Preconditions.checkNotNull(spec, "spec");
+    Preconditions.checkNotNull(spec.getId(), "spec.getId()");
+    Preconditions.checkNotNull(spec.getDataSources(), "spec.getDatasources()");
+    synchronized (lock) {
+      Preconditions.checkState(started, "SupervisorManager not started");
+      try {
+        byte[] specAsBytes = jsonMapper.writeValueAsBytes(spec);
+        Pair<Supervisor, SupervisorSpec> currentSupervisor = supervisors.get(spec.getId());
+        return currentSupervisor == null
+               || !Arrays.equals(specAsBytes, jsonMapper.writeValueAsBytes(currentSupervisor.rhs));
+      }
+      catch (JsonProcessingException ex) {
+        log.warn("Failed to write spec as bytes for spec_id[%s]", spec.getId());
+      }
+    }
+    return true;
+  }
+
   public boolean stopAndRemoveSupervisor(String id)
   {
     Preconditions.checkState(started, "SupervisorManager not started");
@@ -363,8 +404,13 @@ public boolean registerUpgradedPendingSegmentOnSupervisor(
       return true;
     }
     catch (Exception e) {
-      log.error(e, "Failed to upgrade pending segment[%s] to new pending segment[%s] on Supervisor[%s].",
-                upgradedPendingSegment.getUpgradedFromSegmentId(), upgradedPendingSegment.getId().getVersion(), supervisorId);
+      log.error(
+          e,
+          "Failed to upgrade pending segment[%s] to new pending segment[%s] on Supervisor[%s].",
+          upgradedPendingSegment.getUpgradedFromSegmentId(),
+          upgradedPendingSegment.getId().getVersion(),
+          supervisorId
+      );
     }
     return false;
   }
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/supervisor/SupervisorResource.java b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/supervisor/SupervisorResource.java
index 3190835c3e67..354804239f58 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/supervisor/SupervisorResource.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/supervisor/SupervisorResource.java
@@ -119,7 +119,11 @@ public SupervisorResource(
   @POST
   @Consumes(MediaType.APPLICATION_JSON)
   @Produces(MediaType.APPLICATION_JSON)
-  public Response specPost(final SupervisorSpec spec, @Context final HttpServletRequest req)
+  public Response specPost(
+      final SupervisorSpec spec,
+      @QueryParam("skipRestartIfUnmodified") Boolean skipRestartIfUnmodified,
+      @Context final HttpServletRequest req
+  )
   {
     return asLeaderWithSupervisorManager(
         manager -> {
@@ -151,6 +155,9 @@ public Response specPost(final SupervisorSpec spec, @Context final HttpServletRe
           if (!authResult.allowAccessWithNoRestriction()) {
             throw new ForbiddenException(authResult.getErrorMessage());
           }
+          if (Boolean.TRUE.equals(skipRestartIfUnmodified) && !manager.shouldUpdateSupervisor(spec)) {
+            return Response.ok(ImmutableMap.of("id", spec.getId())).build();
+          }
 
           manager.createOrUpdateAndStartSupervisor(spec);
 
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/SupervisorManagerTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/SupervisorManagerTest.java
index 97877052fa08..e7276c6aeadc 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/SupervisorManagerTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/SupervisorManagerTest.java
@@ -19,6 +19,7 @@
 
 package org.apache.druid.indexing.overlord.supervisor;
 
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.base.Optional;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
@@ -33,6 +34,7 @@
 import org.apache.druid.indexing.seekablestream.TestSeekableStreamDataSourceMetadata;
 import org.apache.druid.indexing.seekablestream.supervisor.SeekableStreamSupervisor;
 import org.apache.druid.indexing.seekablestream.supervisor.SeekableStreamSupervisorSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
 import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.metadata.MetadataSupervisorManager;
@@ -60,6 +62,8 @@
 @RunWith(EasyMockRunner.class)
 public class SupervisorManagerTest extends EasyMockSupport
 {
+  private static final ObjectMapper MAPPER = new DefaultObjectMapper();
+
   @Mock
   private MetadataSupervisorManager metadataSupervisorManager;
 
@@ -80,7 +84,7 @@ public class SupervisorManagerTest extends EasyMockSupport
   @Before
   public void setUp()
   {
-    manager = new SupervisorManager(metadataSupervisorManager);
+    manager = new SupervisorManager(MAPPER, metadataSupervisorManager);
   }
 
   @Test
@@ -109,7 +113,6 @@ public void testCreateUpdateAndRemoveSupervisor()
     verifyAll();
 
     resetAll();
-    metadataSupervisorManager.insert("id1", spec2);
     supervisor2.start();
     supervisor1.stop(true);
     replayAll();
@@ -175,6 +178,23 @@ public void testCreateOrUpdateAndStartSupervisorNullSpecId()
     verifyAll();
   }
 
+  @Test
+  public void testShouldUpdateSupervisor()
+  {
+    SupervisorSpec spec = new TestSupervisorSpec("id1", supervisor1);
+    SupervisorSpec spec2 = new TestSupervisorSpec("id2", supervisor2);
+    Map<String, SupervisorSpec> existingSpecs = ImmutableMap.of(
+        "id1", spec
+    );
+    EasyMock.expect(metadataSupervisorManager.getLatest()).andReturn(existingSpecs);
+    supervisor1.start();
+    replayAll();
+    manager.start();
+    Assert.assertFalse(manager.shouldUpdateSupervisor(spec));
+    Assert.assertTrue(manager.shouldUpdateSupervisor(spec2));
+    Assert.assertTrue(manager.shouldUpdateSupervisor(new NoopSupervisorSpec("id1", null)));
+  }
+
   @Test
   public void testStopAndRemoveSupervisorNotStarted()
   {
@@ -533,7 +553,7 @@ public void testGetActiveSupervisorIdForDatasourceWithAppendLock()
     NoopSupervisorSpec noopSupervisorSpec = new NoopSupervisorSpec("noop", ImmutableList.of("noopDS"));
     metadataSupervisorManager.insert(EasyMock.anyString(), EasyMock.anyObject());
 
-    SeekableStreamSupervisorSpec suspendedSpec = EasyMock.mock(SeekableStreamSupervisorSpec.class);
+    SeekableStreamSupervisorSpec suspendedSpec = EasyMock.createNiceMock(SeekableStreamSupervisorSpec.class);
     Supervisor suspendedSupervisor = EasyMock.mock(SeekableStreamSupervisor.class);
     EasyMock.expect(suspendedSpec.getId()).andReturn("suspendedSpec").anyTimes();
     EasyMock.expect(suspendedSpec.isSuspended()).andReturn(true).anyTimes();
@@ -544,7 +564,7 @@ public void testGetActiveSupervisorIdForDatasourceWithAppendLock()
     EasyMock.replay(suspendedSpec);
     metadataSupervisorManager.insert(EasyMock.anyString(), EasyMock.anyObject());
 
-    SeekableStreamSupervisorSpec activeSpec = EasyMock.mock(SeekableStreamSupervisorSpec.class);
+    SeekableStreamSupervisorSpec activeSpec = EasyMock.createNiceMock(SeekableStreamSupervisorSpec.class);
     Supervisor activeSupervisor = EasyMock.mock(SeekableStreamSupervisor.class);
     EasyMock.expect(activeSpec.getId()).andReturn("activeSpec").anyTimes();
     EasyMock.expect(activeSpec.isSuspended()).andReturn(false).anyTimes();
@@ -555,7 +575,7 @@ public void testGetActiveSupervisorIdForDatasourceWithAppendLock()
     EasyMock.replay(activeSpec);
     metadataSupervisorManager.insert(EasyMock.anyString(), EasyMock.anyObject());
 
-    SeekableStreamSupervisorSpec activeSpecWithConcurrentLocks = EasyMock.mock(SeekableStreamSupervisorSpec.class);
+    SeekableStreamSupervisorSpec activeSpecWithConcurrentLocks = EasyMock.createNiceMock(SeekableStreamSupervisorSpec.class);
     Supervisor activeSupervisorWithConcurrentLocks = EasyMock.mock(SeekableStreamSupervisor.class);
     EasyMock.expect(activeSpecWithConcurrentLocks.getId()).andReturn("activeSpecWithConcurrentLocks").anyTimes();
     EasyMock.expect(activeSpecWithConcurrentLocks.isSuspended()).andReturn(false).anyTimes();
@@ -570,7 +590,7 @@ public void testGetActiveSupervisorIdForDatasourceWithAppendLock()
     EasyMock.replay(activeSpecWithConcurrentLocks);
     metadataSupervisorManager.insert(EasyMock.anyString(), EasyMock.anyObject());
 
-    SeekableStreamSupervisorSpec activeAppendSpec = EasyMock.mock(SeekableStreamSupervisorSpec.class);
+    SeekableStreamSupervisorSpec activeAppendSpec = EasyMock.createNiceMock(SeekableStreamSupervisorSpec.class);
     Supervisor activeAppendSupervisor = EasyMock.mock(SeekableStreamSupervisor.class);
     EasyMock.expect(activeAppendSpec.getId()).andReturn("activeAppendSpec").anyTimes();
     EasyMock.expect(activeAppendSpec.isSuspended()).andReturn(false).anyTimes();
@@ -585,7 +605,7 @@ public void testGetActiveSupervisorIdForDatasourceWithAppendLock()
     metadataSupervisorManager.insert(EasyMock.anyString(), EasyMock.anyObject());
 
     // A supervisor with useConcurrentLocks set to false explicitly must not use an append lock
-    SeekableStreamSupervisorSpec specWithUseConcurrentLocksFalse = EasyMock.mock(SeekableStreamSupervisorSpec.class);
+    SeekableStreamSupervisorSpec specWithUseConcurrentLocksFalse = EasyMock.createNiceMock(SeekableStreamSupervisorSpec.class);
     Supervisor supervisorWithUseConcurrentLocksFalse = EasyMock.mock(SeekableStreamSupervisor.class);
     EasyMock.expect(specWithUseConcurrentLocksFalse.getId()).andReturn("useConcurrentLocksFalse").anyTimes();
     EasyMock.expect(specWithUseConcurrentLocksFalse.isSuspended()).andReturn(false).anyTimes();
@@ -639,7 +659,7 @@ public void testRegisterUpgradedPendingSegmentOnSupervisor()
     NoopSupervisorSpec noopSpec = new NoopSupervisorSpec("noop", ImmutableList.of("noopDS"));
     metadataSupervisorManager.insert(EasyMock.anyString(), EasyMock.anyObject());
 
-    SeekableStreamSupervisorSpec streamingSpec = EasyMock.mock(SeekableStreamSupervisorSpec.class);
+    SeekableStreamSupervisorSpec streamingSpec = EasyMock.createNiceMock(SeekableStreamSupervisorSpec.class);
     SeekableStreamSupervisor streamSupervisor = EasyMock.mock(SeekableStreamSupervisor.class);
     streamSupervisor.registerNewVersionOfPendingSegment(EasyMock.anyObject());
     EasyMock.expectLastCall().once();
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/SupervisorResourceTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/SupervisorResourceTest.java
index f07c6c13ab88..febc959b0d10 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/SupervisorResourceTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/SupervisorResourceTest.java
@@ -161,7 +161,7 @@ public List<String> getDataSources()
 
     replayAll();
 
-    Response response = supervisorResource.specPost(spec, request);
+    Response response = supervisorResource.specPost(spec, false, request);
     verifyAll();
 
     Assert.assertEquals(200, response.getStatus());
@@ -171,12 +171,61 @@ public List<String> getDataSources()
     EasyMock.expect(taskMaster.getSupervisorManager()).andReturn(Optional.absent());
     replayAll();
 
-    response = supervisorResource.specPost(spec, request);
+    response = supervisorResource.specPost(spec, false, request);
     verifyAll();
 
     Assert.assertEquals(503, response.getStatus());
   }
 
+  @Test
+  public void testSpecPost_whenSkipRestartIfUnmodifiedIsTrue()
+  {
+    SupervisorSpec spec = new TestSupervisorSpec("my-id", null, null)
+    {
+
+      @Override
+      public List<String> getDataSources()
+      {
+        return List.of("datasource1");
+      }
+    };
+
+    EasyMock.expect(taskMaster.getSupervisorManager()).andReturn(Optional.of(supervisorManager));
+    EasyMock.expect(supervisorManager.shouldUpdateSupervisor(spec)).andReturn(false);
+
+    setupMockRequest();
+
+    EasyMock.expect(authConfig.isEnableInputSourceSecurity()).andReturn(true);
+    replayAll();
+
+    Response response = supervisorResource.specPost(spec, true, request);
+    verifyAll();
+
+    Assert.assertEquals(200, response.getStatus());
+    Assert.assertEquals(ImmutableMap.of("id", "my-id"), response.getEntity());
+
+    resetAll();
+
+    EasyMock.expect(taskMaster.getSupervisorManager()).andReturn(Optional.of(supervisorManager));
+    EasyMock.expect(supervisorManager.shouldUpdateSupervisor(spec)).andReturn(true);
+    EasyMock.expect(supervisorManager.createOrUpdateAndStartSupervisor(spec)).andReturn(true);
+
+    setupMockRequest();
+    setupMockRequestForAudit();
+
+    EasyMock.expect(authConfig.isEnableInputSourceSecurity()).andReturn(true);
+    auditManager.doAudit(EasyMock.anyObject());
+    EasyMock.expectLastCall().once();
+
+    replayAll();
+
+    response = supervisorResource.specPost(spec, true, request);
+    verifyAll();
+
+    Assert.assertEquals(200, response.getStatus());
+    Assert.assertEquals(ImmutableMap.of("id", "my-id"), response.getEntity());
+  }
+
   @Test
   public void testSpecPostWithInputSourceSecurityEnabledAuthorized()
   {
@@ -201,7 +250,7 @@ public List<String> getDataSources()
     EasyMock.expect(authConfig.isEnableInputSourceSecurity()).andReturn(true);
     replayAll();
 
-    Response response = supervisorResource.specPost(spec, request);
+    Response response = supervisorResource.specPost(spec, false, request);
     verifyAll();
 
     Assert.assertEquals(200, response.getStatus());
@@ -211,10 +260,17 @@ public List<String> getDataSources()
     EasyMock.expect(taskMaster.getSupervisorManager()).andReturn(Optional.absent());
     replayAll();
 
-    response = supervisorResource.specPost(spec, request);
+    response = supervisorResource.specPost(spec, false, request);
     verifyAll();
 
     Assert.assertEquals(503, response.getStatus());
+
+    resetAll();
+    EasyMock.expect(taskMaster.getSupervisorManager()).andReturn(Optional.absent());
+    replayAll();
+    response = supervisorResource.specPost(spec, null, request);
+    Assert.assertEquals(503, response.getStatus());
+    verifyAll();
   }
 
   @Test
@@ -230,7 +286,7 @@ public List<String> getDataSources()
       }
     };
 
-    EasyMock.expect(taskMaster.getSupervisorManager()).andReturn(Optional.of(supervisorManager));
+    EasyMock.expect(taskMaster.getSupervisorManager()).andReturn(Optional.of(supervisorManager)).times(2);
     EasyMock.expect(request.getAttribute(AuthConfig.DRUID_ALLOW_UNSECURED_PATH)).andReturn(null).atLeastOnce();
     EasyMock.expect(request.getAttribute(AuthConfig.DRUID_AUTHORIZATION_CHECKED)).andReturn(null).atLeastOnce();
     EasyMock.expect(request.getAttribute(AuthConfig.DRUID_AUTHENTICATION_RESULT)).andReturn(
@@ -238,10 +294,11 @@ public List<String> getDataSources()
     ).atLeastOnce();
     request.setAttribute(AuthConfig.DRUID_AUTHORIZATION_CHECKED, false);
     EasyMock.expectLastCall().anyTimes();
-    EasyMock.expect(authConfig.isEnableInputSourceSecurity()).andReturn(true);
+    EasyMock.expect(authConfig.isEnableInputSourceSecurity()).andReturn(true).times(2);
     replayAll();
 
-    Assert.assertThrows(ForbiddenException.class, () -> supervisorResource.specPost(spec, request));
+    Assert.assertThrows(ForbiddenException.class, () -> supervisorResource.specPost(spec, false, request));
+    Assert.assertThrows(ForbiddenException.class, () -> supervisorResource.specPost(spec, null, request));
     verifyAll();
   }
 
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTaskTestBase.java b/indexing-service/src/test/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTaskTestBase.java
index 1144a77de36d..214c024b4548 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTaskTestBase.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTaskTestBase.java
@@ -609,7 +609,7 @@ protected void makeToolboxFactory(TestUtils testUtils, ServiceEmitter emitter, b
         taskStorage,
         metadataStorageCoordinator,
         emitter,
-        new SupervisorManager(null)
+        new SupervisorManager(OBJECT_MAPPER, null)
         {
           @Override
           public boolean checkPointDataSourceMetadata(
diff --git a/server/src/main/java/org/apache/druid/metadata/SQLMetadataRuleManager.java b/server/src/main/java/org/apache/druid/metadata/SQLMetadataRuleManager.java
index b83f77183aa5..847b1eba6fd6 100644
--- a/server/src/main/java/org/apache/druid/metadata/SQLMetadataRuleManager.java
+++ b/server/src/main/java/org/apache/druid/metadata/SQLMetadataRuleManager.java
@@ -336,6 +336,10 @@ public boolean overrideRule(final String dataSource, final List<Rule> newRules,
     final String ruleString;
     try {
       ruleString = jsonMapper.writeValueAsString(newRules);
+      if (ruleString.equals(jsonMapper.writeValueAsString(rules.get().get(dataSource)))) {
+        log.info("Retention rules unchanged for datasource[%s] with rules[%s]", dataSource, ruleString);
+        return true;
+      }
       log.info("Updating datasource[%s] with rules[%s] as per [%s]", dataSource, ruleString, auditInfo);
     }
     catch (JsonProcessingException e) {
diff --git a/server/src/test/java/org/apache/druid/metadata/SQLMetadataRuleManagerTest.java b/server/src/test/java/org/apache/druid/metadata/SQLMetadataRuleManagerTest.java
index 82a87dd15a98..b31109125094 100644
--- a/server/src/test/java/org/apache/druid/metadata/SQLMetadataRuleManagerTest.java
+++ b/server/src/test/java/org/apache/druid/metadata/SQLMetadataRuleManagerTest.java
@@ -115,6 +115,52 @@ public void testRuleInsert()
     Assert.assertEquals(rules.get(0), allRules.get(TestDataSource.WIKI).get(0));
   }
 
+  @Test
+  public void testAuditEntryNotCreatedWhenRetentionRulesUnchanged()
+  {
+    List<Rule> rules = Collections.singletonList(
+        new IntervalLoadRule(
+            Intervals.of("2015-01-01/2015-02-01"),
+            ImmutableMap.of(DruidServer.DEFAULT_TIER, DruidServer.DEFAULT_NUM_REPLICANTS),
+            null
+        )
+    );
+    ruleManager.overrideRule(TestDataSource.WIKI, rules, createAuditInfo("override rule"));
+    ruleManager.overrideRule(TestDataSource.WIKI, rules, createAuditInfo("override rule"));
+    ruleManager.overrideRule(TestDataSource.WIKI, rules, createAuditInfo("override rule"));
+    Assert.assertEquals(1, auditManager.fetchAuditHistory(TestDataSource.WIKI, "rules", 3).size());
+  }
+
+  @Test
+  public void testAuditEntryCreatedWhenRetentionRulesChanged()
+  {
+    List<Rule> rules = Collections.singletonList(
+        new IntervalLoadRule(
+            Intervals.of("2015-01-01/2015-02-01"),
+            ImmutableMap.of(DruidServer.DEFAULT_TIER, DruidServer.DEFAULT_NUM_REPLICANTS),
+            null
+        )
+    );
+    ruleManager.overrideRule(TestDataSource.WIKI, rules, createAuditInfo("override rule"));
+    rules = Collections.singletonList(
+        new IntervalLoadRule(
+            Intervals.of("2015-01-01/2015-02-02"),
+            ImmutableMap.of(DruidServer.DEFAULT_TIER, DruidServer.DEFAULT_NUM_REPLICANTS),
+            null
+        )
+    );
+    ruleManager.overrideRule(TestDataSource.WIKI, rules, createAuditInfo("override rule"));
+    rules = Collections.singletonList(
+        new IntervalLoadRule(
+            Intervals.of("2015-01-01/2015-02-03"),
+            ImmutableMap.of(DruidServer.DEFAULT_TIER, DruidServer.DEFAULT_NUM_REPLICANTS),
+            null
+        )
+    );
+    ruleManager.overrideRule(TestDataSource.WIKI, rules, createAuditInfo("override rule"));
+    Assert.assertEquals(3, auditManager.fetchAuditHistory(TestDataSource.WIKI, "rules", 3).size());
+  }
+
   @Test
   public void testOverrideRuleWithNull()
   {

From 04206329feaeeeb5c974f67a6e2833c88e1c0b35 Mon Sep 17 00:00:00 2001
From: Kashif Faraz <kashif.faraz@gmail.com>
Date: Wed, 5 Mar 2025 16:38:40 +0530
Subject: [PATCH 19/99] Reduce noisy coordinator logs (#17779)

---
 .../server/coordinator/balancer/SegmentToMoveCalculator.java  | 4 ++--
 .../druid/server/coordinator/duty/UnloadUnusedSegments.java   | 2 +-
 .../druid/server/coordinator/loading/HttpLoadQueuePeon.java   | 2 --
 .../druid/server/coordinator/loading/LoadQueueTaskMaster.java | 1 +
 .../java/org/apache/druid/server/coordinator/stats/Stats.java | 2 +-
 5 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/server/src/main/java/org/apache/druid/server/coordinator/balancer/SegmentToMoveCalculator.java b/server/src/main/java/org/apache/druid/server/coordinator/balancer/SegmentToMoveCalculator.java
index 01c7da44c116..e45ed65abc9a 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/balancer/SegmentToMoveCalculator.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/balancer/SegmentToMoveCalculator.java
@@ -248,7 +248,7 @@ static int computeSegmentsToMoveToBalanceCountsPerDatasource(
 
     final int numSegmentsToMove = maxCountDifference.getKey() / 2;
     if (numSegmentsToMove > 0) {
-      log.info(
+      log.debug(
           "Need to move [%,d] segments of datasource[%s] in tier[%s] to fix gap between min[%,d] and max[%,d].",
           numSegmentsToMove, mostUnbalancedDatasource, tier, minNumSegments, maxNumSegments
       );
@@ -290,7 +290,7 @@ private static int computeSegmentsToMoveToBalanceDiskUsage(
                                   ? 0 : (int) (differenceInUsageBytes / averageSegmentSize) / 2;
 
     if (numSegmentsToMove > 0) {
-      log.info(
+      log.debug(
           "Need to move [%,d] segments of avg size [%,d MB] in tier[%s] to fix"
           + " disk usage gap between min[%d GB][%.1f%%] and max[%d GB][%.1f%%].",
           numSegmentsToMove, ((long) averageSegmentSize) >> 20, tier,
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/duty/UnloadUnusedSegments.java b/server/src/main/java/org/apache/druid/server/coordinator/duty/UnloadUnusedSegments.java
index 53f7abd6f6d9..2bd9fd295481 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/duty/UnloadUnusedSegments.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/duty/UnloadUnusedSegments.java
@@ -73,7 +73,7 @@ public DruidCoordinatorRuntimeParams run(DruidCoordinatorRuntimeParams params)
     ).sum();
 
     if (numCancelledLoads > 0 || numQueuedDrops > 0) {
-      log.info("Cancelled [%d] loads and started [%d] drops of unused segments.", numCancelledLoads, numQueuedDrops);
+      log.debug("Cancelled [%d] loads and started [%d] drops of unused segments.", numCancelledLoads, numQueuedDrops);
     }
 
     return params;
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeon.java b/server/src/main/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeon.java
index cf1a239b59d7..015b5686769d 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeon.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeon.java
@@ -382,12 +382,10 @@ public void stop()
       if (stopped) {
         return;
       }
-      log.info("Stopping load queue peon for server[%s].", serverId);
       stopped = true;
 
       if (!queuedSegments.isEmpty()) {
         queuedSegments.forEach(holder -> onRequestCompleted(holder, RequestStatus.CANCELLED));
-        log.info("Cancelled [%d] requests queued on server[%s].", queuedSegments.size(), serverId);
       }
 
       segmentsToDrop.clear();
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/loading/LoadQueueTaskMaster.java b/server/src/main/java/org/apache/druid/server/coordinator/loading/LoadQueueTaskMaster.java
index 647c9e0c4132..ed6d2d5a3ea3 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/loading/LoadQueueTaskMaster.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/loading/LoadQueueTaskMaster.java
@@ -132,6 +132,7 @@ public synchronized void onLeaderStop()
   {
     isLeader.set(false);
 
+    log.info("Stopping load queue peon for [%d] servers.", loadManagementPeons.size());
     loadManagementPeons.values().forEach(LoadQueuePeon::stop);
     loadManagementPeons.clear();
   }
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/stats/Stats.java b/server/src/main/java/org/apache/druid/server/coordinator/stats/Stats.java
index 959ef24d3935..0bc3b609bd38 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/stats/Stats.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/stats/Stats.java
@@ -32,7 +32,7 @@ public static class Segments
     public static final CoordinatorStat DROPPED
         = CoordinatorStat.toDebugAndEmit("dropped", "segment/dropped/count");
     public static final CoordinatorStat DELETED
-        = CoordinatorStat.toLogAndEmit("deleted", "segment/deleted/count", CoordinatorStat.Level.INFO);
+        = CoordinatorStat.toDebugAndEmit("deleted", "segment/deleted/count");
     public static final CoordinatorStat MOVED
         = CoordinatorStat.toDebugAndEmit("moved", "segment/moved/count");
 

From 5dc7142a7efbfebc1752656dbf20dc063df299c2 Mon Sep 17 00:00:00 2001
From: Adithya Chakilam <35785271+adithyachakilam@users.noreply.github.com>
Date: Wed, 5 Mar 2025 10:40:43 -0600
Subject: [PATCH 20/99] Emit time lag from Kafka supervisor (#17735)

Changes
---------
- Emit time lag from Kafka similar to Kinesis as metrics `ingest/kafka/lag/time`,
`ingest/kafka/maxLag/time`, `ingest/kafka/avgLag/time`
- Add new method in `KafkaSupervisor` to fetch timestamps of latest records in stream to compute time lag
- Add new field `emitTimeLagMetrics` in `KafkaSupervisorIOConfig` to toggle emission of new metrics
---
 docs/operations/metrics.md                    |   5 +
 .../RabbitStreamRecordSupplier.java           |   1 -
 .../indexing/kafka/KafkaRecordSupplier.java   |  19 ++-
 .../kafka/supervisor/KafkaSupervisor.java     | 110 +++++++++++++++++-
 .../supervisor/KafkaSupervisorIOConfig.java   |  15 ++-
 .../KafkaSupervisorReportPayload.java         |   3 +-
 .../indexing/kafka/KafkaSamplerSpecTest.java  |  18 ++-
 .../KafkaSupervisorIOConfigTest.java          |   6 +-
 .../kafka/supervisor/KafkaSupervisorTest.java |  23 +++-
 .../common/OrderedPartitionableRecord.java    |  22 ++++
 .../seekablestream/common/RecordSupplier.java |  11 ++
 .../supervisor/SeekableStreamSupervisor.java  |  19 +++
 12 files changed, 233 insertions(+), 19 deletions(-)

diff --git a/docs/operations/metrics.md b/docs/operations/metrics.md
index ba74079de397..926740b5fb42 100644
--- a/docs/operations/metrics.md
+++ b/docs/operations/metrics.md
@@ -223,6 +223,10 @@ These metrics apply to the [Kafka indexing service](../ingestion/kafka-ingestion
 |`ingest/kafka/maxLag`|Max lag between the offsets consumed by the Kafka indexing tasks and latest offsets in Kafka brokers across all partitions. Minimum emission period for this metric is a minute.|`dataSource`, `stream`, `tags`|Greater than 0, should not be a very high number. |
 |`ingest/kafka/avgLag`|Average lag between the offsets consumed by the Kafka indexing tasks and latest offsets in Kafka brokers across all partitions. Minimum emission period for this metric is a minute.|`dataSource`, `stream`, `tags`|Greater than 0, should not be a very high number. |
 |`ingest/kafka/partitionLag`|Partition-wise lag between the offsets consumed by the Kafka indexing tasks and latest offsets in Kafka brokers. Minimum emission period for this metric is a minute.|`dataSource`, `stream`, `partition`, `tags`|Greater than 0, should not be a very high number. |
+|`ingest/kafka/updateOffsets/time`|Total time (in milliseconds) taken to fetch the latest offsets from Kafka stream and the ingestion tasks.|`dataSource`, `taskId`, `taskType`, `groupId`, `tags`|Generally a few seconds at most.|
+|`ingest/kafka/lag/time`|Total lag time in milliseconds between the current message sequence number consumed by the Kafka indexing tasks and latest sequence number in Kafka across all shards. Minimum emission period for this metric is a minute. Enabled only when `pusblishLagTime` is set to true on supervisor config.|`dataSource`, `stream`, `tags`|Greater than 0, up to max kafka retention period in milliseconds. |
+|`ingest/kafka/maxLag/time`|Max lag time in milliseconds between the current message sequence number consumed by the Kafka indexing tasks and latest sequence number in Kafka across all shards. Minimum emission period for this metric is a minute. Enabled only when `pusblishLagTime` is set to true on supervisor config.|`dataSource`, `stream`, `tags`|Greater than 0, up to max kafka retention period in milliseconds. |
+|`ingest/kafka/avgLag/time`|Average lag time in milliseconds between the current message sequence number consumed by the Kafka indexing tasks and latest sequence number in Kafka across all shards. Minimum emission period for this metric is a minute. Enabled only when `pusblishLagTime` is set to true on supervisor config.|`dataSource`, `stream`, `tags`|Greater than 0, up to max kafka retention period in milliseconds. |
 
 ### Ingestion metrics for Kinesis
 
@@ -234,6 +238,7 @@ These metrics apply to the [Kinesis indexing service](../ingestion/kinesis-inges
 |`ingest/kinesis/maxLag/time`|Max lag time in milliseconds between the current message sequence number consumed by the Kinesis indexing tasks and latest sequence number in Kinesis across all shards. Minimum emission period for this metric is a minute.|`dataSource`, `stream`, `tags`|Greater than 0, up to max Kinesis retention period in milliseconds. |
 |`ingest/kinesis/avgLag/time`|Average lag time in milliseconds between the current message sequence number consumed by the Kinesis indexing tasks and latest sequence number in Kinesis across all shards. Minimum emission period for this metric is a minute.|`dataSource`, `stream`, `tags`|Greater than 0, up to max Kinesis retention period in milliseconds. |
 |`ingest/kinesis/partitionLag/time`|Partition-wise lag time in milliseconds between the current message sequence number consumed by the Kinesis indexing tasks and latest sequence number in Kinesis. Minimum emission period for this metric is a minute.|`dataSource`, `stream`, `partition`, `tags`|Greater than 0, up to max Kinesis retention period in milliseconds. |
+|`ingest/kinesis/updateOffsets/time`|Total time (in milliseconds) taken to fetch the latest offsets from Kafka stream and the ingestion tasks.|`dataSource`, `taskId`, `taskType`, `groupId`, `tags`|Generally a few seconds at most.|
 
 ### Compaction metrics
 
diff --git a/extensions-contrib/rabbit-stream-indexing-service/src/main/java/org/apache/druid/indexing/rabbitstream/RabbitStreamRecordSupplier.java b/extensions-contrib/rabbit-stream-indexing-service/src/main/java/org/apache/druid/indexing/rabbitstream/RabbitStreamRecordSupplier.java
index 56d7cf44ea1d..b2a2432fc9c0 100644
--- a/extensions-contrib/rabbit-stream-indexing-service/src/main/java/org/apache/druid/indexing/rabbitstream/RabbitStreamRecordSupplier.java
+++ b/extensions-contrib/rabbit-stream-indexing-service/src/main/java/org/apache/druid/indexing/rabbitstream/RabbitStreamRecordSupplier.java
@@ -43,7 +43,6 @@
 import org.apache.druid.metadata.DynamicConfigProvider;
 
 import javax.annotation.Nonnull;
-
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.ArrayList;
diff --git a/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/KafkaRecordSupplier.java b/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/KafkaRecordSupplier.java
index a88300552e2a..ac7683a25ef4 100644
--- a/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/KafkaRecordSupplier.java
+++ b/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/KafkaRecordSupplier.java
@@ -38,6 +38,7 @@
 import org.apache.druid.java.util.metrics.Monitor;
 import org.apache.druid.metadata.DynamicConfigProvider;
 import org.apache.druid.metadata.PasswordProvider;
+import org.apache.druid.utils.CollectionUtils;
 import org.apache.kafka.clients.consumer.ConsumerRecord;
 import org.apache.kafka.clients.consumer.KafkaConsumer;
 import org.apache.kafka.common.PartitionInfo;
@@ -166,7 +167,8 @@ public List<OrderedPartitionableRecord<KafkaTopicPartition, Long, KafkaRecordEnt
           record.topic(),
           new KafkaTopicPartition(multiTopic, record.topic(), record.partition()),
           record.offset(),
-          record.value() == null ? null : ImmutableList.of(new KafkaRecordEntity(record))
+          record.value() == null ? null : ImmutableList.of(new KafkaRecordEntity(record)),
+          record.timestamp()
       ));
     }
     return polledRecords;
@@ -206,6 +208,21 @@ public Long getPosition(StreamPartition<KafkaTopicPartition> partition)
     return wrapExceptions(() -> consumer.position(partition.getPartitionId().asTopicPartition(partition.getStream())));
   }
 
+  @Override
+  public Map<KafkaTopicPartition, Long> getLatestSequenceNumbers(Set<StreamPartition<KafkaTopicPartition>> partitions)
+  {
+    return wrapExceptions(() -> CollectionUtils.mapKeys(
+      consumer.endOffsets(
+        partitions
+            .stream()
+            .map(e -> e.getPartitionId().asTopicPartition(e.getStream()))
+            .collect(Collectors.toList()
+        )
+      ),
+      p -> new KafkaTopicPartition(multiTopic, p.topic(), p.partition())
+    ));
+  }
+
   @Override
   public Set<KafkaTopicPartition> getPartitionIds(String stream)
   {
diff --git a/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisor.java b/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisor.java
index a0c7494e3bbe..b990c8fa3fc6 100644
--- a/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisor.java
+++ b/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisor.java
@@ -46,6 +46,7 @@
 import org.apache.druid.indexing.seekablestream.SeekableStreamIndexTaskTuningConfig;
 import org.apache.druid.indexing.seekablestream.SeekableStreamSequenceNumbers;
 import org.apache.druid.indexing.seekablestream.SeekableStreamStartSequenceNumbers;
+import org.apache.druid.indexing.seekablestream.common.OrderedPartitionableRecord;
 import org.apache.druid.indexing.seekablestream.common.OrderedSequenceNumber;
 import org.apache.druid.indexing.seekablestream.common.RecordSupplier;
 import org.apache.druid.indexing.seekablestream.common.StreamException;
@@ -91,6 +92,7 @@ public class KafkaSupervisor extends SeekableStreamSupervisor<KafkaTopicPartitio
 
   private final Pattern pattern;
   private volatile Map<KafkaTopicPartition, Long> latestSequenceFromStream;
+  private volatile Map<KafkaTopicPartition, Long> partitionToTimeLag;
 
   private final KafkaSupervisorSpec spec;
 
@@ -171,6 +173,7 @@ protected SeekableStreamSupervisorReportPayload<KafkaTopicPartition, Long> creat
         ioConfig.getTaskDuration().getMillis() / 1000,
         includeOffsets ? latestSequenceFromStream : null,
         includeOffsets ? partitionLag : null,
+        includeOffsets ? getPartitionTimeLag() : null,
         includeOffsets ? partitionLag.values().stream().mapToLong(x -> Math.max(x, 0)).sum() : null,
         includeOffsets ? sequenceLastUpdated : null,
         spec.isSuspended(),
@@ -273,8 +276,7 @@ protected Map<KafkaTopicPartition, Long> getPartitionRecordLag()
   @Override
   protected Map<KafkaTopicPartition, Long> getPartitionTimeLag()
   {
-    // time lag not currently support with kafka
-    return null;
+    return partitionToTimeLag;
   }
 
   // suppress use of CollectionUtils.mapValues() since the valueMapper function is dependent on map key here
@@ -380,6 +382,105 @@ public LagStats computeLagStats()
     return computeLags(partitionRecordLag);
   }
 
+  /**
+   * This method is similar to updatePartitionLagFromStream
+   * but also determines time lag. Once this method has been
+   * tested, we can remove the older one.
+   */
+  private void updatePartitionTimeAndRecordLagFromStream()
+  {
+    final Map<KafkaTopicPartition, Long> highestCurrentOffsets = getHighestCurrentOffsets();
+
+    getRecordSupplierLock().lock();
+    try {
+      Set<KafkaTopicPartition> partitionIds;
+      try {
+        partitionIds = recordSupplier.getPartitionIds(getIoConfig().getStream());
+      }
+      catch (Exception e) {
+        log.warn("Could not fetch partitions for topic/stream [%s]", getIoConfig().getStream());
+        throw new StreamException(e);
+      }
+
+      final Set<StreamPartition<KafkaTopicPartition>> partitions = partitionIds
+          .stream()
+          .map(e -> new StreamPartition<>(getIoConfig().getStream(), e))
+          .collect(Collectors.toSet());
+
+      // Since we cannot compute the current timestamp for partitions for
+      // which we haven't started reading yet explictly set them.
+      final Set<KafkaTopicPartition> yetToReadPartitions = new HashSet<>();
+      for (KafkaTopicPartition partition : partitionIds) {
+        Long highestCurrentOffset = highestCurrentOffsets.get(partition);
+        if (highestCurrentOffset == null || highestCurrentOffset == 0) {
+          yetToReadPartitions.add(partition);
+        } else {
+          recordSupplier.seek(new StreamPartition<>(getIoConfig().getStream(), partition), highestCurrentOffset - 1);
+        }
+      }
+
+      final Map<KafkaTopicPartition, Long> lastIngestedTimestamps = getTimestampPerPartitionAtCurrentOffset(partitions);
+      // Note: this might give weird values for lag when the tasks are yet to start processing
+      yetToReadPartitions.forEach(p -> lastIngestedTimestamps.put(p, 0L));
+
+      recordSupplier.seekToLatest(partitions);
+      latestSequenceFromStream = recordSupplier.getLatestSequenceNumbers(partitions);
+
+      for (Map.Entry<KafkaTopicPartition, Long> entry : latestSequenceFromStream.entrySet()) {
+        // if there are no messages .getEndOffset would return 0, but if there are n msgs it would return n+1
+        // and hence we need to seek to n - 2 to get the nth msg in the next poll.
+        if (entry.getValue() != 0) {
+          recordSupplier.seek(new StreamPartition<>(getIoConfig().getStream(), entry.getKey()), entry.getValue() - 2);
+        }
+      }
+
+      partitionToTimeLag = getTimestampPerPartitionAtCurrentOffset(partitions)
+          .entrySet().stream().filter(e -> lastIngestedTimestamps.containsKey(e.getKey()))
+          .collect(
+              Collectors.toMap(
+                  Entry::getKey,
+                  e -> e.getValue() - lastIngestedTimestamps.get(e.getKey())
+              )
+          );
+    }
+    catch (InterruptedException e) {
+      throw new StreamException(e);
+    }
+    finally {
+      getRecordSupplierLock().unlock();
+    }
+  }
+
+  private Map<KafkaTopicPartition, Long> getTimestampPerPartitionAtCurrentOffset(Set<StreamPartition<KafkaTopicPartition>> allPartitions)
+  {
+    Map<KafkaTopicPartition, Long> result = new HashMap<>();
+    Set<StreamPartition<KafkaTopicPartition>> remainingPartitions = new HashSet<>(allPartitions);
+
+    try {
+      int maxPolls = 5;
+      while (!remainingPartitions.isEmpty() && maxPolls-- > 0) {
+        for (OrderedPartitionableRecord<KafkaTopicPartition, Long, KafkaRecordEntity> record : recordSupplier.poll(getIoConfig().getPollTimeout())) {
+          if (!result.containsKey(record.getPartitionId())) {
+            result.put(record.getPartitionId(), record.getTimestamp());
+            remainingPartitions.remove(new StreamPartition<>(getIoConfig().getStream(), record.getPartitionId()));
+            if (remainingPartitions.isEmpty()) {
+              break;
+            }
+          }
+          recordSupplier.assign(remainingPartitions);
+        }
+      }
+    }
+    finally {
+      recordSupplier.assign(allPartitions);
+    }
+
+    if (!remainingPartitions.isEmpty()) {
+      log.info("Could not fetch the latest timestamp for partitions [%s].", remainingPartitions);
+    }
+    return result;
+  }
+
   /**
    * Fetches the latest offsets from the Kafka stream and updates the map
    * {@link #latestSequenceFromStream}. The actual lag is computed lazily in
@@ -388,6 +489,11 @@ public LagStats computeLagStats()
   @Override
   protected void updatePartitionLagFromStream()
   {
+    if (getIoConfig().isEmitTimeLagMetrics()) {
+      updatePartitionTimeAndRecordLagFromStream();
+      return;
+    }
+
     getRecordSupplierLock().lock();
     try {
       Set<KafkaTopicPartition> partitionIds;
diff --git a/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisorIOConfig.java b/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisorIOConfig.java
index fbf55f4ab5ed..be4f6cfb1961 100644
--- a/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisorIOConfig.java
+++ b/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisorIOConfig.java
@@ -22,6 +22,7 @@
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.base.Preconditions;
+import org.apache.druid.common.config.Configs;
 import org.apache.druid.data.input.InputFormat;
 import org.apache.druid.error.InvalidInput;
 import org.apache.druid.indexing.seekablestream.extension.KafkaConfigOverrides;
@@ -51,6 +52,7 @@ public class KafkaSupervisorIOConfig extends SeekableStreamSupervisorIOConfig
   private final KafkaConfigOverrides configOverrides;
   private final String topic;
   private final String topicPattern;
+  private final boolean emitTimeLagMetrics;
 
   @JsonCreator
   public KafkaSupervisorIOConfig(
@@ -72,7 +74,8 @@ public KafkaSupervisorIOConfig(
       @JsonProperty("lateMessageRejectionStartDateTime") DateTime lateMessageRejectionStartDateTime,
       @JsonProperty("configOverrides") KafkaConfigOverrides configOverrides,
       @JsonProperty("idleConfig") IdleConfig idleConfig,
-      @JsonProperty("stopTaskCount") Integer stopTaskCount
+      @JsonProperty("stopTaskCount") Integer stopTaskCount,
+      @Nullable @JsonProperty("emitTimeLagMetrics") Boolean emitTimeLagMetrics
   )
   {
     super(
@@ -102,6 +105,7 @@ public KafkaSupervisorIOConfig(
     this.configOverrides = configOverrides;
     this.topic = topic;
     this.topicPattern = topicPattern;
+    this.emitTimeLagMetrics = Configs.valueOrDefault(emitTimeLagMetrics, false);
   }
 
   /**
@@ -151,6 +155,15 @@ public boolean isMultiTopic()
     return topicPattern != null;
   }
 
+  /**
+   * @return true if supervisor needs to publish the time lag.
+   */
+  @JsonProperty
+  public boolean isEmitTimeLagMetrics()
+  {
+    return emitTimeLagMetrics;
+  }
+
   @Override
   public String toString()
   {
diff --git a/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisorReportPayload.java b/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisorReportPayload.java
index 6a88dc16ec84..c64c4426d692 100644
--- a/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisorReportPayload.java
+++ b/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisorReportPayload.java
@@ -38,6 +38,7 @@ public KafkaSupervisorReportPayload(
       long durationSeconds,
       @Nullable Map<KafkaTopicPartition, Long> latestOffsets,
       @Nullable Map<KafkaTopicPartition, Long> minimumLag,
+      @Nullable Map<KafkaTopicPartition, Long> minimumLagMillis,
       @Nullable Long aggregateLag,
       @Nullable DateTime offsetsLastUpdated,
       boolean suspended,
@@ -56,7 +57,7 @@ public KafkaSupervisorReportPayload(
         latestOffsets,
         minimumLag,
         aggregateLag,
-        null,
+        minimumLagMillis,
         null,
         offsetsLastUpdated,
         suspended,
diff --git a/extensions-core/kafka-indexing-service/src/test/java/org/apache/druid/indexing/kafka/KafkaSamplerSpecTest.java b/extensions-core/kafka-indexing-service/src/test/java/org/apache/druid/indexing/kafka/KafkaSamplerSpecTest.java
index 9ed5f068e0bc..dd7efcdea519 100644
--- a/extensions-core/kafka-indexing-service/src/test/java/org/apache/druid/indexing/kafka/KafkaSamplerSpecTest.java
+++ b/extensions-core/kafka-indexing-service/src/test/java/org/apache/druid/indexing/kafka/KafkaSamplerSpecTest.java
@@ -165,7 +165,8 @@ public void testSample()
             null,
             null,
             null,
-            null
+            null,
+            false
         ),
         null,
         null,
@@ -218,7 +219,8 @@ public void testSampleWithTopicPattern()
             null,
             null,
             null,
-            null
+            null,
+            false
         ),
         null,
         null,
@@ -280,7 +282,8 @@ public void testSampleKafkaInputFormat()
             null,
             null,
             null,
-            null
+            null,
+            false
         ),
         null,
         null,
@@ -384,7 +387,8 @@ public void testWithInputRowParser() throws IOException
             null,
             null,
             null,
-            null
+            null,
+            false
         ),
         null,
         null,
@@ -568,7 +572,8 @@ public void testInvalidKafkaConfig()
             null,
             null,
             null,
-            null
+            null,
+            false
         ),
         null,
         null,
@@ -624,7 +629,8 @@ public void testGetInputSourceResources()
             null,
             null,
             null,
-            null
+            null,
+            false
         ),
         null,
         null,
diff --git a/extensions-core/kafka-indexing-service/src/test/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisorIOConfigTest.java b/extensions-core/kafka-indexing-service/src/test/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisorIOConfigTest.java
index 64ac05865d64..cb2956afd3b9 100644
--- a/extensions-core/kafka-indexing-service/src/test/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisorIOConfigTest.java
+++ b/extensions-core/kafka-indexing-service/src/test/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisorIOConfigTest.java
@@ -337,7 +337,8 @@ public void testAutoScalingConfigSerde() throws JsonProcessingException
         null,
         null,
         null,
-        null
+        null,
+        false
     );
     String ioConfig = mapper.writeValueAsString(kafkaSupervisorIOConfig);
     KafkaSupervisorIOConfig kafkaSupervisorIOConfig1 = mapper.readValue(ioConfig, KafkaSupervisorIOConfig.class);
@@ -380,7 +381,8 @@ public void testIdleConfigSerde() throws JsonProcessingException
         null,
         null,
         mapper.convertValue(idleConfig, IdleConfig.class),
-        null
+        null,
+        false
     );
     String ioConfig = mapper.writeValueAsString(kafkaSupervisorIOConfig);
     KafkaSupervisorIOConfig kafkaSupervisorIOConfig1 = mapper.readValue(ioConfig, KafkaSupervisorIOConfig.class);
diff --git a/extensions-core/kafka-indexing-service/src/test/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisorTest.java b/extensions-core/kafka-indexing-service/src/test/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisorTest.java
index f330c97f0ea9..3eb0d2a8df83 100644
--- a/extensions-core/kafka-indexing-service/src/test/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisorTest.java
+++ b/extensions-core/kafka-indexing-service/src/test/java/org/apache/druid/indexing/kafka/supervisor/KafkaSupervisorTest.java
@@ -119,6 +119,8 @@
 import org.junit.runners.Parameterized;
 
 import java.io.IOException;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -319,7 +321,8 @@ public SeekableStreamIndexTaskClient<KafkaTopicPartition, Long> build(
         null,
         null,
         new IdleConfig(true, 1000L),
-        1
+        1,
+        false
     );
 
     final KafkaSupervisorTuningConfig tuningConfigOri = new KafkaSupervisorTuningConfig(
@@ -2093,7 +2096,7 @@ public void testDiscoverExistingPublishingTaskWithDifferentPartitionAllocation()
 
     supervisor = getTestableSupervisor(1, 1, true, "PT1H", null, null);
     final KafkaSupervisorTuningConfig tuningConfig = supervisor.getTuningConfig();
-    addSomeEvents(1);
+    addSomeEvents(30);
 
     Task task = createKafkaIndexTask(
         "id1",
@@ -2324,6 +2327,10 @@ public void testDiscoverExistingPublishingAndReadingTask() throws Exception
     Assert.assertEquals(1, payload.getPublishingTasks().size());
     Assert.assertEquals(SupervisorStateManager.BasicState.RUNNING, payload.getDetailedState());
     Assert.assertEquals(0, payload.getRecentErrors().size());
+    Assert.assertEquals(
+        singlePartitionMap(topic, 0, 10000, 1, 5000, 2, 0),
+        payload.getMinimumLagMillis()
+    );
 
     TaskReportData activeReport = payload.getActiveTasks().get(0);
     TaskReportData publishingReport = payload.getPublishingTasks().get(0);
@@ -5115,16 +5122,19 @@ private void addSomeEvents(int numEventsPerPartition) throws Exception
     try (final KafkaProducer<byte[], byte[]> kafkaProducer = kafkaServer.newProducer()) {
       kafkaProducer.initTransactions();
       kafkaProducer.beginTransaction();
+      Instant time = Instant.now();
       for (int i = 0; i < NUM_PARTITIONS; i++) {
         for (int j = 0; j < numEventsPerPartition; j++) {
           kafkaProducer.send(
               new ProducerRecord<>(
                   topic,
                   i,
+                  time.toEpochMilli(),
                   null,
                   StringUtils.toUtf8(StringUtils.format("event-%d", j))
               )
           ).get();
+          time = time.plus(5, ChronoUnit.SECONDS);
         }
       }
       kafkaProducer.commitTransaction();
@@ -5286,7 +5296,8 @@ private TestableKafkaSupervisor getTestableSupervisor(
         null,
         null,
         idleConfig,
-        null
+        null,
+        true
     );
 
     KafkaIndexTaskClientFactory taskClientFactory = new KafkaIndexTaskClientFactory(
@@ -5400,7 +5411,8 @@ private TestableKafkaSupervisor getTestableSupervisorCustomIsTaskCurrent(
         null,
         null,
         null,
-        null
+        null,
+        false
     );
 
     KafkaIndexTaskClientFactory taskClientFactory = new KafkaIndexTaskClientFactory(
@@ -5517,7 +5529,8 @@ private KafkaSupervisor createSupervisor(
         null,
         null,
         null,
-        null
+        null,
+        false
     );
 
     KafkaIndexTaskClientFactory taskClientFactory = new KafkaIndexTaskClientFactory(
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/common/OrderedPartitionableRecord.java b/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/common/OrderedPartitionableRecord.java
index 5d052585ba98..17a7ab3dd5d9 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/common/OrderedPartitionableRecord.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/common/OrderedPartitionableRecord.java
@@ -41,6 +41,7 @@ public class OrderedPartitionableRecord<PartitionIdType, SequenceOffsetType, Rec
   private final PartitionIdType partitionId;
   private final SequenceOffsetType sequenceNumber;
   private final List<RecordType> data;
+  private final Long timestamp;
 
   public OrderedPartitionableRecord(
       String stream,
@@ -48,6 +49,17 @@ public OrderedPartitionableRecord(
       SequenceOffsetType sequenceNumber,
       List<RecordType> data
   )
+  {
+    this(stream, partitionId, sequenceNumber, data, null);
+  }
+
+  public OrderedPartitionableRecord(
+      String stream,
+      PartitionIdType partitionId,
+      SequenceOffsetType sequenceNumber,
+      List<RecordType> data,
+      Long timestamp
+  )
   {
     Preconditions.checkNotNull(stream, "stream");
     Preconditions.checkNotNull(partitionId, "partitionId");
@@ -56,6 +68,7 @@ public OrderedPartitionableRecord(
     this.partitionId = partitionId;
     this.sequenceNumber = sequenceNumber;
     this.data = data == null ? ImmutableList.of() : data;
+    this.timestamp = timestamp;
   }
 
   public String getStream()
@@ -63,6 +76,15 @@ public String getStream()
     return stream;
   }
 
+  /**
+   *
+   * @return Timestamp in millis when the record was published to the stream, -1 if not known
+   */
+  public long getTimestamp()
+  {
+    return timestamp;
+  }
+
   public PartitionIdType getPartitionId()
   {
     return partitionId;
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/common/RecordSupplier.java b/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/common/RecordSupplier.java
index b9db4202a8f3..1c7e32480255 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/common/RecordSupplier.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/common/RecordSupplier.java
@@ -27,6 +27,7 @@
 import java.io.Closeable;
 import java.util.Collection;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 /**
@@ -132,6 +133,16 @@ boolean isOffsetAvailable(StreamPartition<PartitionIdType> partition,
    */
   Set<PartitionIdType> getPartitionIds(String stream);
 
+  /**
+   * Returns the end offsets for all the assigned partitions.
+   *
+   * @return Map from Partition ID to the corresponding end offset
+   */
+  default Map<PartitionIdType, SequenceOffsetType> getLatestSequenceNumbers(Set<StreamPartition<PartitionIdType>> partitions)
+  {
+    throw new UnsupportedOperationException();
+  }
+
   /**
    * close the RecordSupplier
    */
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java b/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java
index faa68f3d8ea1..47781826265a 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java
@@ -4093,6 +4093,7 @@ public void updateCurrentAndLatestOffsets()
     // healthy go ahead and try anyway to try if possible to provide insight into how much time is left to fix the
     // issue for cluster operators since this feeds the lag metrics
     if (stateManager.isIdle() || stateManager.isSteadyState() || !stateManager.isHealthy()) {
+      final Stopwatch runTime = Stopwatch.createStarted();
       try {
         updateCurrentOffsets();
         updatePartitionLagFromStream();
@@ -4101,6 +4102,9 @@ public void updateCurrentAndLatestOffsets()
       catch (Exception e) {
         log.warn(e, "Exception while getting current/latest sequences");
       }
+      finally {
+        emitUpdateOffsetsTime(runTime.millisElapsed());
+      }
     }
   }
 
@@ -4506,6 +4510,21 @@ protected void emitNoticeProcessTime(String noticeType, long timeInMillis)
     }
   }
 
+  private void emitUpdateOffsetsTime(long timeInMillis)
+  {
+    try {
+      emitter.emit(
+          ServiceMetricEvent.builder()
+                            .setDimension(DruidMetrics.DATASOURCE, dataSource)
+                            .setDimensionIfNotNull(DruidMetrics.TAGS, spec.getContextValue(DruidMetrics.TAGS))
+                            .setMetric(StringUtils.format("ingest/%s/fetchOffsets/time", spec.getType()), timeInMillis)
+      );
+    }
+    catch (Exception e) {
+      log.warn(e, "Unable to emit updateOffsets time");
+    }
+  }
+
   protected void emitNoticesQueueSize()
   {
     if (spec.isSuspended()) {

From 33d49a5163ee41a6c01ce43311023fe4824183e4 Mon Sep 17 00:00:00 2001
From: Vadim Ogievetsky <vadim@ogievetsky.com>
Date: Wed, 5 Mar 2025 13:11:20 -0800
Subject: [PATCH 21/99] fix processed row formatting (#17756)

---
 .../supervisor-statistics-table.tsx           | 14 ++++----
 .../supervisors-view/supervisors-view.tsx     | 34 ++++++++++++++-----
 2 files changed, 33 insertions(+), 15 deletions(-)

diff --git a/web-console/src/dialogs/supervisor-table-action-dialog/supervisor-statistics-table/supervisor-statistics-table.tsx b/web-console/src/dialogs/supervisor-table-action-dialog/supervisor-statistics-table/supervisor-statistics-table.tsx
index d0c9ee8756ce..96d4f05333ad 100644
--- a/web-console/src/dialogs/supervisor-table-action-dialog/supervisor-statistics-table/supervisor-statistics-table.tsx
+++ b/web-console/src/dialogs/supervisor-table-action-dialog/supervisor-statistics-table/supervisor-statistics-table.tsx
@@ -76,16 +76,18 @@ export const SupervisorStatisticsTable = React.memo(function SupervisorStatistic
 
     const formatNumber = isRate ? formatRate : formatInteger;
     const formatData = isRate ? formatByteRate : formatBytes;
-    const bytes = c.processedBytes ? ` (${formatData(c.processedBytes)})` : '';
-    return (
+    return c.processedBytes ? (
       <div>
-        <div>{`Processed: ${formatNumber(c.processed)}${bytes}`}</div>
+        <div>{`Input: ${formatData(c.processedBytes)}`}</div>
+        {Boolean(c.processed) && <div>{`Processed: ${formatNumber(c.processed)}`}</div>}
         {Boolean(c.processedWithError) && (
-          <div>Processed with error: {formatNumber(c.processedWithError)}</div>
+          <div>{`Processed with error: ${formatNumber(c.processedWithError)}`}</div>
         )}
-        {Boolean(c.thrownAway) && <div>Thrown away: {formatNumber(c.thrownAway)}</div>}
-        {Boolean(c.unparseable) && <div>Unparseable: {formatNumber(c.unparseable)}</div>}
+        {Boolean(c.thrownAway) && <div>{`Thrown away: ${formatNumber(c.thrownAway)}`}</div>}
+        {Boolean(c.unparseable) && <div>{`Unparseable: ${formatNumber(c.unparseable)}`}</div>}
       </div>
+    ) : (
+      <div>No activity</div>
     );
   }
 
diff --git a/web-console/src/views/supervisors-view/supervisors-view.tsx b/web-console/src/views/supervisors-view/supervisors-view.tsx
index 75a0e9482f57..0b1bd9a19d29 100644
--- a/web-console/src/views/supervisors-view/supervisors-view.tsx
+++ b/web-console/src/views/supervisors-view/supervisors-view.tsx
@@ -875,19 +875,25 @@ export class SupervisorsView extends React.PureComponent<
 
               const c = getTotalSupervisorStats(value, statsKey, activeTaskIds);
               const seconds = getRowStatsKeySeconds(statsKey);
+              const issues =
+                (c.processedWithError || 0) + (c.thrownAway || 0) + (c.unparseable || 0);
               const totalLabel = `Total (past ${statsKey}): `;
-              const bytes = c.processedBytes ? ` (${formatByteRate(c.processedBytes)})` : '';
-              return (
+              return issues ? (
                 <div>
                   <div
-                    data-tooltip={`${totalLabel}${formatInteger(
-                      c.processed * seconds,
-                    )} (${formatBytes(c.processedBytes * seconds)})`}
-                  >{`Processed: ${formatRate(c.processed)}${bytes}`}</div>
+                    data-tooltip={`${totalLabel}${formatBytes(c.processedBytes * seconds)}`}
+                  >{`Input: ${formatByteRate(c.processedBytes)}`}</div>
+                  {Boolean(c.processed) && (
+                    <div
+                      data-tooltip={`${totalLabel}${formatInteger(c.processed * seconds)} events`}
+                    >{`Processed: ${formatRate(c.processed)}`}</div>
+                  )}
                   {Boolean(c.processedWithError) && (
                     <div
                       className="warning-line"
-                      data-tooltip={`${totalLabel}${formatInteger(c.processedWithError * seconds)}`}
+                      data-tooltip={`${totalLabel}${formatInteger(
+                        c.processedWithError * seconds,
+                      )} events`}
                     >
                       Processed with error: {formatRate(c.processedWithError)}
                     </div>
@@ -895,7 +901,7 @@ export class SupervisorsView extends React.PureComponent<
                   {Boolean(c.thrownAway) && (
                     <div
                       className="warning-line"
-                      data-tooltip={`${totalLabel}${formatInteger(c.thrownAway * seconds)}`}
+                      data-tooltip={`${totalLabel}${formatInteger(c.thrownAway * seconds)} events`}
                     >
                       Thrown away: {formatRate(c.thrownAway)}
                     </div>
@@ -903,12 +909,22 @@ export class SupervisorsView extends React.PureComponent<
                   {Boolean(c.unparseable) && (
                     <div
                       className="warning-line"
-                      data-tooltip={`${totalLabel}${formatInteger(c.unparseable * seconds)}`}
+                      data-tooltip={`${totalLabel}${formatInteger(c.unparseable * seconds)} events`}
                     >
                       Unparseable: {formatRate(c.unparseable)}
                     </div>
                   )}
                 </div>
+              ) : c.processedBytes ? (
+                <div
+                  data-tooltip={`${totalLabel}${formatInteger(
+                    c.processed * seconds,
+                  )} events, ${formatBytes(c.processedBytes * seconds)}`}
+                >{`Processed: ${formatRate(c.processed)} (${formatByteRate(
+                  c.processedBytes,
+                )})`}</div>
+              ) : (
+                <div>No activity</div>
               );
             },
             show: visibleColumns.shown('Stats'),

From ae84ddae30a14de12d83784ae3c2d1d684363c64 Mon Sep 17 00:00:00 2001
From: Vadim Ogievetsky <vadim@ogievetsky.com>
Date: Wed, 5 Mar 2025 13:12:29 -0800
Subject: [PATCH 22/99] Web console: add suggestions for table status
 filtering. (#17765)

* suggest filter values when known

* update snapshots

* add more d

* fix load rule clamp

* better segment timeline init
---
 .../components/menu-boolean/menu-boolean.tsx  |  6 +-
 .../segment-bar-chart-render.tsx              |  4 +-
 .../src/react-table/react-table-inputs.tsx    | 53 ++++++++++++++++++
 .../src/react-table/react-table-utils.ts      | 56 +++++++++++--------
 web-console/src/utils/general.tsx             |  5 ++
 .../datasources-view/datasources-view.tsx     | 14 ++++-
 .../values-filter-control.tsx                 |  3 +-
 .../components/helper-table/helper-table.tsx  |  3 +-
 .../nested-column-dialog.tsx                  |  9 ++-
 .../src/views/explore-view/utils/misc.ts      |  5 --
 .../src/views/segments-view/segments-view.tsx | 14 ++++-
 .../__snapshots__/services-view.spec.tsx.snap |  1 +
 .../src/views/services-view/services-view.tsx | 16 +++++-
 .../schema-step/schema-step.tsx               |  4 +-
 .../supervisors-view.spec.tsx.snap            |  1 +
 .../supervisors-view/supervisors-view.tsx     | 15 +++++
 .../__snapshots__/tasks-view.spec.tsx.snap    |  1 +
 .../src/views/tasks-view/tasks-view.tsx       | 14 ++++-
 .../workbench-view/run-panel/run-panel.tsx    | 18 +++---
 19 files changed, 186 insertions(+), 56 deletions(-)

diff --git a/web-console/src/components/menu-boolean/menu-boolean.tsx b/web-console/src/components/menu-boolean/menu-boolean.tsx
index 0d77d7e315e4..2457f8486430 100644
--- a/web-console/src/components/menu-boolean/menu-boolean.tsx
+++ b/web-console/src/components/menu-boolean/menu-boolean.tsx
@@ -31,9 +31,9 @@ function toKey(value: boolean | undefined) {
 
 const DEFAULT_OPTIONS_TEXT: Partial<Record<TrueFalseUndefined, string>> = { undefined: 'Auto' };
 
-export const ENABLE_DISABLE_OPTIONS_TEXT: Partial<Record<TrueFalseUndefined, string>> = {
-  true: 'Enable',
-  false: 'Disable',
+export const ENABLED_DISABLED_OPTIONS_TEXT: Partial<Record<TrueFalseUndefined, string>> = {
+  true: 'Enabled',
+  false: 'Disabled',
   undefined: 'Auto',
 };
 
diff --git a/web-console/src/components/segment-timeline/segment-bar-chart-render.tsx b/web-console/src/components/segment-timeline/segment-bar-chart-render.tsx
index bb04259b53d6..630dc4231497 100644
--- a/web-console/src/components/segment-timeline/segment-bar-chart-render.tsx
+++ b/web-console/src/components/segment-timeline/segment-bar-chart-render.tsx
@@ -644,8 +644,8 @@ export const SegmentBarChartRender = function SegmentBarChartRender(
         className={classNames('load-rule', loadRuleToBaseType(loadRule))}
         data-tooltip={title}
         style={{
-          left: xWidth.x,
-          width: xWidth.width,
+          left: clamp(xWidth.x, 0, innerStage.width),
+          width: clamp(xWidth.width, 0, innerStage.width),
         }}
       >
         {title}
diff --git a/web-console/src/react-table/react-table-inputs.tsx b/web-console/src/react-table/react-table-inputs.tsx
index 22ff5f64bd2a..79932b490e4f 100644
--- a/web-console/src/react-table/react-table-inputs.tsx
+++ b/web-console/src/react-table/react-table-inputs.tsx
@@ -22,6 +22,8 @@ import classNames from 'classnames';
 import { useEffect, useState } from 'react';
 import type { Column, ReactTableFunction } from 'react-table';
 
+import { filterMap, toggle } from '../utils';
+
 import {
   combineModeAndNeedle,
   FILTER_MODES,
@@ -113,6 +115,57 @@ export function GenericFilterInput({ column, filter, onChange, key }: FilterRend
   );
 }
 
+export function suggestibleFilterInput(suggestions: string[]) {
+  return function SuggestibleFilterInput({ filter, onChange, key, ...rest }: FilterRendererProps) {
+    let valuesFilteredOn: string[] | undefined;
+    if (filter) {
+      const modeAndNeedle = parseFilterModeAndNeedle(filter, true);
+      if (modeAndNeedle && modeAndNeedle.mode === '=') {
+        valuesFilteredOn = modeAndNeedle.needleParts;
+      }
+    }
+    return (
+      <Popover
+        key={key}
+        placement="bottom-start"
+        minimal
+        content={
+          <Menu>
+            {filterMap(suggestions, (suggestion, i) => {
+              return (
+                <MenuItem
+                  key={i}
+                  icon={
+                    valuesFilteredOn
+                      ? valuesFilteredOn.includes(suggestion)
+                        ? IconNames.MINUS
+                        : IconNames.PLUS
+                      : IconNames.EQUALS
+                  }
+                  text={suggestion}
+                  onClick={() =>
+                    onChange(
+                      combineModeAndNeedle(
+                        '=',
+                        valuesFilteredOn
+                          ? toggle(valuesFilteredOn, suggestion).join('|')
+                          : suggestion,
+                        true,
+                      ),
+                    )
+                  }
+                />
+              );
+            })}
+          </Menu>
+        }
+      >
+        <GenericFilterInput filter={filter} onChange={onChange} {...rest} />
+      </Popover>
+    );
+  };
+}
+
 export function BooleanFilterInput({ filter, onChange, key }: FilterRendererProps) {
   return (
     <HTMLSelect
diff --git a/web-console/src/react-table/react-table-utils.ts b/web-console/src/react-table/react-table-utils.ts
index 7732c90b231c..bb19dddae2d0 100644
--- a/web-console/src/react-table/react-table-utils.ts
+++ b/web-console/src/react-table/react-table-utils.ts
@@ -81,6 +81,7 @@ export function filterModeToTitle(mode: FilterMode): string {
 interface FilterModeAndNeedle {
   mode: FilterMode;
   needle: string;
+  needleParts: string[];
 }
 
 export function addFilter(
@@ -100,13 +101,16 @@ export function parseFilterModeAndNeedle(
   if (!m) return;
   if (!loose && !m[2]) return;
   const mode = (m[1] as FilterMode) || '~';
+  const needle = m[2] || '';
   return {
     mode,
-    needle: m[2] || '',
+    needle,
+    needleParts: needle.split('|'),
   };
 }
 
-export function combineModeAndNeedle(mode: FilterMode, needle: string): string {
+export function combineModeAndNeedle(mode: FilterMode, needle: string, cleanup = false): string {
+  if (cleanup && needle === '') return '';
   return `${mode}${needle}`;
 }
 
@@ -116,60 +120,64 @@ export function addOrUpdateFilter(filters: readonly Filter[], filter: Filter): F
 
 export function booleanCustomTableFilter(filter: Filter, value: unknown): boolean {
   if (value == null) return false;
-  const modeAndNeedle = parseFilterModeAndNeedle(filter);
-  if (!modeAndNeedle) return true;
-  const { mode, needle } = modeAndNeedle;
+  const modeAndNeedles = parseFilterModeAndNeedle(filter);
+  if (!modeAndNeedles) return true;
+  const { mode, needleParts } = modeAndNeedles;
   const strValue = String(value);
   switch (mode) {
     case '=':
-      return strValue === needle;
+      return needleParts.some(needle => strValue === needle);
 
     case '!=':
-      return strValue !== needle;
+      return needleParts.every(needle => strValue !== needle);
 
     case '<':
-      return strValue < needle;
+      return needleParts.some(needle => strValue < needle);
 
     case '<=':
-      return strValue <= needle;
+      return needleParts.some(needle => strValue <= needle);
 
     case '>':
-      return strValue > needle;
+      return needleParts.some(needle => strValue > needle);
 
     case '>=':
-      return strValue >= needle;
+      return needleParts.some(needle => strValue >= needle);
 
     default:
-      return caseInsensitiveContains(strValue, needle);
+      return needleParts.some(needle => caseInsensitiveContains(strValue, needle));
   }
 }
 
 export function sqlQueryCustomTableFilter(filter: Filter): SqlExpression | undefined {
-  const modeAndNeedle = parseFilterModeAndNeedle(filter);
-  if (!modeAndNeedle) return;
-  const { mode, needle } = modeAndNeedle;
+  const modeAndNeedles = parseFilterModeAndNeedle(filter);
+  if (!modeAndNeedles) return;
+  const { mode, needleParts } = modeAndNeedles;
   const column = C(filter.id);
   switch (mode) {
-    case '=':
-      return column.equal(needle);
+    case '=': {
+      return SqlExpression.or(...needleParts.map(needle => column.equal(needle)));
+    }
 
-    case '!=':
-      return column.unequal(needle);
+    case '!=': {
+      return SqlExpression.and(...needleParts.map(needle => column.unequal(needle)));
+    }
 
     case '<':
-      return column.lessThan(needle);
+      return SqlExpression.or(...needleParts.map(needle => column.lessThan(needle)));
 
     case '<=':
-      return column.lessThanOrEqual(needle);
+      return SqlExpression.or(...needleParts.map(needle => column.lessThanOrEqual(needle)));
 
     case '>':
-      return column.greaterThan(needle);
+      return SqlExpression.or(...needleParts.map(needle => column.greaterThan(needle)));
 
     case '>=':
-      return column.greaterThanOrEqual(needle);
+      return SqlExpression.or(...needleParts.map(needle => column.greaterThanOrEqual(needle)));
 
     default:
-      return F('LOWER', column).like(`%${needle.toLowerCase()}%`);
+      return SqlExpression.or(
+        ...needleParts.map(needle => F('LOWER', column).like(`%${needle.toLowerCase()}%`)),
+      );
   }
 }
 
diff --git a/web-console/src/utils/general.tsx b/web-console/src/utils/general.tsx
index 9aefb5631f7a..8af818664fd1 100644
--- a/web-console/src/utils/general.tsx
+++ b/web-console/src/utils/general.tsx
@@ -686,3 +686,8 @@ export function offsetToRowColumn(str: string, offset: number): RowColumn | unde
 export function xor(a: unknown, b: unknown): boolean {
   return Boolean(a ? !b : b);
 }
+
+export function toggle<T>(xs: readonly T[], x: T, eq?: (a: T, b: T) => boolean): T[] {
+  const e = eq || ((a, b) => a === b);
+  return xs.find(_ => e(_, x)) ? xs.filter(d => !e(d, x)) : xs.concat([x]);
+}
diff --git a/web-console/src/views/datasources-view/datasources-view.tsx b/web-console/src/views/datasources-view/datasources-view.tsx
index f4f652befed6..4921027100ad 100644
--- a/web-console/src/views/datasources-view/datasources-view.tsx
+++ b/web-console/src/views/datasources-view/datasources-view.tsx
@@ -70,6 +70,7 @@ import {
   compact,
   countBy,
   deepGet,
+  findMap,
   formatBytes,
   formatInteger,
   formatMillions,
@@ -1709,7 +1710,7 @@ GROUP BY 1, 2`;
   }
 
   render() {
-    const { capabilities, goToSegments } = this.props;
+    const { capabilities, filters, goToSegments } = this.props;
     const {
       showUnused,
       visibleColumns,
@@ -1737,7 +1738,16 @@ GROUP BY 1, 2`;
             label="Show segment timeline"
             onChange={() =>
               this.setState({
-                showSegmentTimeline: showSegmentTimeline ? undefined : { capabilities },
+                showSegmentTimeline: showSegmentTimeline
+                  ? undefined
+                  : {
+                      capabilities,
+                      datasource: findMap(filters, filter =>
+                        filter.id === 'datasource' && /^=[^=|]+$/.exec(String(filter.value))
+                          ? filter.value.slice(1)
+                          : undefined,
+                      ),
+                    },
               })
             }
             disabled={!capabilities.hasSqlOrCoordinatorAccess()}
diff --git a/web-console/src/views/explore-view/components/filter-pane/filter-menu/values-filter-control/values-filter-control.tsx b/web-console/src/views/explore-view/components/filter-pane/filter-menu/values-filter-control/values-filter-control.tsx
index 93304f628ae2..f14851f081fb 100644
--- a/web-console/src/views/explore-view/components/filter-pane/filter-menu/values-filter-control/values-filter-control.tsx
+++ b/web-console/src/views/explore-view/components/filter-pane/filter-menu/values-filter-control/values-filter-control.tsx
@@ -25,9 +25,8 @@ import React, { useMemo, useState } from 'react';
 
 import { ClearableInput } from '../../../../../../components';
 import { useQueryManager } from '../../../../../../hooks';
-import { caseInsensitiveContains, filterMap } from '../../../../../../utils';
+import { caseInsensitiveContains, filterMap, toggle } from '../../../../../../utils';
 import type { QuerySource } from '../../../../models';
-import { toggle } from '../../../../utils';
 import { ColumnValue } from '../../../column-value/column-value';
 
 import './values-filter-control.scss';
diff --git a/web-console/src/views/explore-view/components/helper-table/helper-table.tsx b/web-console/src/views/explore-view/components/helper-table/helper-table.tsx
index 42ad3ae45d7e..2f6ee09153ca 100644
--- a/web-console/src/views/explore-view/components/helper-table/helper-table.tsx
+++ b/web-console/src/views/explore-view/components/helper-table/helper-table.tsx
@@ -37,11 +37,12 @@ import {
   checkedCircleIcon,
   filterMap,
   formatNumber,
+  toggle,
   without,
   xor,
 } from '../../../../utils';
 import type { ExpressionMeta, QuerySource } from '../../models';
-import { addOrUpdatePattern, toggle } from '../../utils';
+import { addOrUpdatePattern } from '../../utils';
 import { ColumnValue } from '../column-value/column-value';
 
 import './helper-table.scss';
diff --git a/web-console/src/views/explore-view/components/resource-pane/nested-column-dialog/nested-column-dialog.tsx b/web-console/src/views/explore-view/components/resource-pane/nested-column-dialog/nested-column-dialog.tsx
index acb2e2c4775d..133661c564bf 100644
--- a/web-console/src/views/explore-view/components/resource-pane/nested-column-dialog/nested-column-dialog.tsx
+++ b/web-console/src/views/explore-view/components/resource-pane/nested-column-dialog/nested-column-dialog.tsx
@@ -33,10 +33,15 @@ import React, { useState } from 'react';
 
 import { ClearableInput, Loader, MenuCheckbox } from '../../../../../components';
 import { useQueryManager } from '../../../../../hooks';
-import { caseInsensitiveContains, filterMap, pluralIfNeeded, wait } from '../../../../../utils';
+import {
+  caseInsensitiveContains,
+  filterMap,
+  pluralIfNeeded,
+  toggle,
+  wait,
+} from '../../../../../utils';
 import type { QuerySource } from '../../../models';
 import { ExpressionMeta } from '../../../models';
-import { toggle } from '../../../utils';
 
 import './nested-column-dialog.scss';
 
diff --git a/web-console/src/views/explore-view/utils/misc.ts b/web-console/src/views/explore-view/utils/misc.ts
index 3f461b1d6c89..8b0c917c87aa 100644
--- a/web-console/src/views/explore-view/utils/misc.ts
+++ b/web-console/src/views/explore-view/utils/misc.ts
@@ -19,11 +19,6 @@
 import { nonEmptyArray } from '../../../utils';
 import type { ParameterDefinition } from '../models';
 
-export function toggle<T>(xs: readonly T[], x: T, eq?: (a: T, b: T) => boolean): T[] {
-  const e = eq || ((a, b) => a === b);
-  return xs.find(_ => e(_, x)) ? xs.filter(d => !e(d, x)) : xs.concat([x]);
-}
-
 export function normalizeType(paramType: ParameterDefinition['type']): ParameterDefinition['type'] {
   switch (paramType) {
     case 'expressions':
diff --git a/web-console/src/views/segments-view/segments-view.tsx b/web-console/src/views/segments-view/segments-view.tsx
index 5ac84089aa1a..ff3b0f76d8b7 100644
--- a/web-console/src/views/segments-view/segments-view.tsx
+++ b/web-console/src/views/segments-view/segments-view.tsx
@@ -62,6 +62,7 @@ import {
   compact,
   countBy,
   filterMap,
+  findMap,
   formatBytes,
   formatInteger,
   getApiArray,
@@ -1004,7 +1005,7 @@ export class SegmentsView extends React.PureComponent<SegmentsViewProps, Segment
   }
 
   render() {
-    const { capabilities, onFiltersChange } = this.props;
+    const { capabilities, filters, onFiltersChange } = this.props;
     const {
       segmentTableActionDialogId,
       datasourceTableActionDialogId,
@@ -1047,7 +1048,16 @@ export class SegmentsView extends React.PureComponent<SegmentsViewProps, Segment
             label="Show segment timeline"
             onChange={() =>
               this.setState({
-                showSegmentTimeline: showSegmentTimeline ? undefined : { capabilities },
+                showSegmentTimeline: showSegmentTimeline
+                  ? undefined
+                  : {
+                      capabilities,
+                      datasource: findMap(filters, filter =>
+                        filter.id === 'datasource' && /^=[^=|]+$/.exec(String(filter.value))
+                          ? filter.value.slice(1)
+                          : undefined,
+                      ),
+                    },
               })
             }
             disabled={!capabilities.hasSqlOrCoordinatorAccess()}
diff --git a/web-console/src/views/services-view/__snapshots__/services-view.spec.tsx.snap b/web-console/src/views/services-view/__snapshots__/services-view.spec.tsx.snap
index 3e4e05a451fd..b304833a8cce 100644
--- a/web-console/src/views/services-view/__snapshots__/services-view.spec.tsx.snap
+++ b/web-console/src/views/services-view/__snapshots__/services-view.spec.tsx.snap
@@ -132,6 +132,7 @@ exports[`ServicesView renders data 1`] = `
         },
         {
           "Cell": [Function],
+          "Filter": [Function],
           "Header": "Type",
           "accessor": "service_type",
           "show": true,
diff --git a/web-console/src/views/services-view/services-view.tsx b/web-console/src/views/services-view/services-view.tsx
index e658d9355947..2a68eaed1cdc 100644
--- a/web-console/src/views/services-view/services-view.tsx
+++ b/web-console/src/views/services-view/services-view.tsx
@@ -38,7 +38,11 @@ import {
 import { AsyncActionDialog } from '../../dialogs';
 import type { QueryWithContext } from '../../druid-models';
 import type { Capabilities, CapabilitiesMode } from '../../helpers';
-import { STANDARD_TABLE_PAGE_SIZE, STANDARD_TABLE_PAGE_SIZE_OPTIONS } from '../../react-table';
+import {
+  STANDARD_TABLE_PAGE_SIZE,
+  STANDARD_TABLE_PAGE_SIZE_OPTIONS,
+  suggestibleFilterInput,
+} from '../../react-table';
 import { Api, AppToaster } from '../../singletons';
 import type { AuxiliaryQueryFn, NumberLike } from '../../utils';
 import {
@@ -417,6 +421,16 @@ ORDER BY
           {
             Header: 'Type',
             show: visibleColumns.shown('Type'),
+            Filter: suggestibleFilterInput([
+              'coordinator',
+              'overlord',
+              'router',
+              'broker',
+              'historical',
+              'indexer',
+              'middle_manager',
+              'peon',
+            ]),
             accessor: 'service_type',
             width: 150,
             Cell: this.renderFilterableCell('service_type'),
diff --git a/web-console/src/views/sql-data-loader-view/schema-step/schema-step.tsx b/web-console/src/views/sql-data-loader-view/schema-step/schema-step.tsx
index 27b24a8350a0..232c6635361f 100644
--- a/web-console/src/views/sql-data-loader-view/schema-step/schema-step.tsx
+++ b/web-console/src/views/sql-data-loader-view/schema-step/schema-step.tsx
@@ -48,7 +48,7 @@ import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } fr
 
 import {
   ClearableInput,
-  ENABLE_DISABLE_OPTIONS_TEXT,
+  ENABLED_DISABLED_OPTIONS_TEXT,
   LearnMore,
   Loader,
   MenuBoolean,
@@ -694,7 +694,7 @@ export const SchemaStep = function SchemaStep(props: SchemaStepProps) {
                     text="Force segment sort by time"
                     value={forceSegmentSortByTime}
                     onValueChange={v => changeForceSegmentSortByTime(Boolean(v))}
-                    optionsText={ENABLE_DISABLE_OPTIONS_TEXT}
+                    optionsText={ENABLED_DISABLED_OPTIONS_TEXT}
                     optionsLabelElement={{ false: EXPERIMENTAL_ICON }}
                   />
                 </Menu>
diff --git a/web-console/src/views/supervisors-view/__snapshots__/supervisors-view.spec.tsx.snap b/web-console/src/views/supervisors-view/__snapshots__/supervisors-view.spec.tsx.snap
index f9a450468e79..273fa44d9db5 100644
--- a/web-console/src/views/supervisors-view/__snapshots__/supervisors-view.spec.tsx.snap
+++ b/web-console/src/views/supervisors-view/__snapshots__/supervisors-view.spec.tsx.snap
@@ -183,6 +183,7 @@ exports[`SupervisorsView matches snapshot 1`] = `
         },
         {
           "Cell": [Function],
+          "Filter": [Function],
           "Header": "Status",
           "accessor": "detailed_state",
           "id": "detailed_state",
diff --git a/web-console/src/views/supervisors-view/supervisors-view.tsx b/web-console/src/views/supervisors-view/supervisors-view.tsx
index 0b1bd9a19d29..89ad8ebfcb99 100644
--- a/web-console/src/views/supervisors-view/supervisors-view.tsx
+++ b/web-console/src/views/supervisors-view/supervisors-view.tsx
@@ -58,6 +58,7 @@ import {
   SMALL_TABLE_PAGE_SIZE,
   SMALL_TABLE_PAGE_SIZE_OPTIONS,
   sqlQueryCustomTableFilters,
+  suggestibleFilterInput,
 } from '../../react-table';
 import { Api, AppToaster } from '../../singletons';
 import type { AuxiliaryQueryFn, TableState } from '../../utils';
@@ -741,6 +742,20 @@ export class SupervisorsView extends React.PureComponent<
             Header: 'Status',
             id: 'detailed_state',
             width: 150,
+            Filter: suggestibleFilterInput([
+              'CONNECTING_TO_STREAM',
+              'CREATING_TASKS',
+              'DISCOVERING_INITIAL_TASKS',
+              'IDLE',
+              'LOST_CONTACT_WITH_STREAM',
+              'PENDING',
+              'RUNNING',
+              'STOPPING',
+              'SUSPENDED',
+              'UNABLE_TO_CONNECT_TO_STREAM',
+              'UNHEALTHY_SUPERVISOR',
+              'UNHEALTHY_TASKS',
+            ]),
             accessor: 'detailed_state',
             Cell: ({ value }) => (
               <TableFilterableCell
diff --git a/web-console/src/views/tasks-view/__snapshots__/tasks-view.spec.tsx.snap b/web-console/src/views/tasks-view/__snapshots__/tasks-view.spec.tsx.snap
index b3927f64e9a0..3e702f91d451 100644
--- a/web-console/src/views/tasks-view/__snapshots__/tasks-view.spec.tsx.snap
+++ b/web-console/src/views/tasks-view/__snapshots__/tasks-view.spec.tsx.snap
@@ -174,6 +174,7 @@ exports[`TasksView matches snapshot 1`] = `
         },
         {
           "Cell": [Function],
+          "Filter": [Function],
           "Header": "Status",
           "accessor": [Function],
           "id": "status",
diff --git a/web-console/src/views/tasks-view/tasks-view.tsx b/web-console/src/views/tasks-view/tasks-view.tsx
index f968b7d4925f..7dc9b2ab5b00 100644
--- a/web-console/src/views/tasks-view/tasks-view.tsx
+++ b/web-console/src/views/tasks-view/tasks-view.tsx
@@ -38,7 +38,11 @@ import { AlertDialog, AsyncActionDialog, SpecDialog, TaskTableActionDialog } fro
 import type { QueryWithContext } from '../../druid-models';
 import { TASK_CANCELED_ERROR_MESSAGES, TASK_CANCELED_PREDICATE } from '../../druid-models';
 import type { Capabilities } from '../../helpers';
-import { SMALL_TABLE_PAGE_SIZE, SMALL_TABLE_PAGE_SIZE_OPTIONS } from '../../react-table';
+import {
+  SMALL_TABLE_PAGE_SIZE,
+  SMALL_TABLE_PAGE_SIZE_OPTIONS,
+  suggestibleFilterInput,
+} from '../../react-table';
 import { Api, AppToaster } from '../../singletons';
 import {
   formatDuration,
@@ -408,6 +412,14 @@ ORDER BY
             Header: 'Status',
             id: 'status',
             width: 110,
+            Filter: suggestibleFilterInput([
+              'CANCELED',
+              'FAILED',
+              'PENDING',
+              'RUNNING',
+              'SUCCESS',
+              'WAITING',
+            ]),
             accessor: row => ({
               status: row.status,
               created_time: row.created_time,
diff --git a/web-console/src/views/workbench-view/run-panel/run-panel.tsx b/web-console/src/views/workbench-view/run-panel/run-panel.tsx
index a3a7548856e2..9ca4f3004023 100644
--- a/web-console/src/views/workbench-view/run-panel/run-panel.tsx
+++ b/web-console/src/views/workbench-view/run-panel/run-panel.tsx
@@ -34,7 +34,7 @@ import type { JSX } from 'react';
 import React, { useCallback, useMemo, useState } from 'react';
 
 import {
-  ENABLE_DISABLE_OPTIONS_TEXT,
+  ENABLED_DISABLED_OPTIONS_TEXT,
   MenuBoolean,
   MenuCheckbox,
   TimezoneMenuItems,
@@ -414,7 +414,7 @@ export const RunPanel = React.memo(function RunPanel(props: RunPanelProps) {
                         useApproximateCountDistinct,
                       })
                     }
-                    optionsText={ENABLE_DISABLE_OPTIONS_TEXT}
+                    optionsText={ENABLED_DISABLED_OPTIONS_TEXT}
                   />
                 )}
                 {show('approximate-top-n') && (
@@ -428,7 +428,7 @@ export const RunPanel = React.memo(function RunPanel(props: RunPanelProps) {
                         useApproximateTopN,
                       })
                     }
-                    optionsText={ENABLE_DISABLE_OPTIONS_TEXT}
+                    optionsText={ENABLED_DISABLED_OPTIONS_TEXT}
                   />
                 )}
                 {show('join-algorithm') && (
@@ -465,7 +465,7 @@ export const RunPanel = React.memo(function RunPanel(props: RunPanelProps) {
                       onValueChange={failOnEmptyInsert =>
                         changeQueryContext({ ...queryContext, failOnEmptyInsert })
                       }
-                      optionsText={ENABLE_DISABLE_OPTIONS_TEXT}
+                      optionsText={ENABLED_DISABLED_OPTIONS_TEXT}
                     />
                     <MenuBoolean
                       text="Wait until segments have loaded"
@@ -475,7 +475,7 @@ export const RunPanel = React.memo(function RunPanel(props: RunPanelProps) {
                       onValueChange={waitUntilSegmentsLoad =>
                         changeQueryContext({ ...queryContext, waitUntilSegmentsLoad })
                       }
-                      optionsText={ENABLE_DISABLE_OPTIONS_TEXT}
+                      optionsText={ENABLED_DISABLED_OPTIONS_TEXT}
                     />
                     <MenuItem text="Max parse exceptions" label={String(maxParseExceptions)}>
                       {[0, 1, 5, 10, 1000, 10000, -1].map(v => (
@@ -511,7 +511,7 @@ export const RunPanel = React.memo(function RunPanel(props: RunPanelProps) {
                     onValueChange={finalizeAggregations =>
                       changeQueryContext({ ...queryContext, finalizeAggregations })
                     }
-                    optionsText={ENABLE_DISABLE_OPTIONS_TEXT}
+                    optionsText={ENABLED_DISABLED_OPTIONS_TEXT}
                   />
                 )}
                 {show('group-by-enable-multi-value-unnesting') && (
@@ -524,7 +524,7 @@ export const RunPanel = React.memo(function RunPanel(props: RunPanelProps) {
                     onValueChange={groupByEnableMultiValueUnnesting =>
                       changeQueryContext({ ...queryContext, groupByEnableMultiValueUnnesting })
                     }
-                    optionsText={ENABLE_DISABLE_OPTIONS_TEXT}
+                    optionsText={ENABLED_DISABLED_OPTIONS_TEXT}
                   />
                 )}
 
@@ -540,7 +540,7 @@ export const RunPanel = React.memo(function RunPanel(props: RunPanelProps) {
                         populateCache: useCache,
                       })
                     }
-                    optionsText={ENABLE_DISABLE_OPTIONS_TEXT}
+                    optionsText={ENABLED_DISABLED_OPTIONS_TEXT}
                   />
                 )}
                 {show('limit-inline-results') && (
@@ -568,7 +568,7 @@ export const RunPanel = React.memo(function RunPanel(props: RunPanelProps) {
                         durableShuffleStorage,
                       })
                     }
-                    optionsText={ENABLE_DISABLE_OPTIONS_TEXT}
+                    optionsText={ENABLED_DISABLED_OPTIONS_TEXT}
                   />
                 )}
                 {show('select-destination') && (

From 9416d0368c9439da70fb1f888b3170980e651ac6 Mon Sep 17 00:00:00 2001
From: Kashif Faraz <kashif.faraz@gmail.com>
Date: Thu, 6 Mar 2025 11:37:40 +0530
Subject: [PATCH 23/99] Remove all usages of skife config (#17776)

Changes
---------
- Usages of skife config had been deprecated in #14695 and
`LegacyBrokerParallelMergeConfig` is the last config class that still uses it.
- Remove `org.skife.config` from pom, licenses, log4j2.xml, etc.
- Add validation for deleted property paths in `StartupInjectorBuilder.PropertiesValidator`
- Use the replacement flattened configs (which remove the `.task` and `.pool` substring)
---
 docs/configuration/index.md                   |  12 +-
 docs/configuration/logging.md                 |   3 -
 docs/querying/query-context.md                |   6 +-
 examples/conf/druid/auto/_common/log4j2.xml   |   3 -
 .../conf/druid/cluster/_common/log4j2.xml     |   3 -
 .../single-server/large/_common/log4j2.xml    |   3 -
 .../single-server/medium/_common/log4j2.xml   |   3 -
 .../micro-quickstart/_common/log4j2.xml       |   3 -
 .../nano-quickstart/_common/log4j2.xml        |   3 -
 .../single-server/small/_common/log4j2.xml    |   3 -
 .../single-server/xlarge/_common/log4j2.xml   |   3 -
 .../druid/testsEx/config/Initializer.java     |   5 +-
 licenses.yaml                                 |  10 --
 pom.xml                                       |  11 --
 processing/pom.xml                            |   4 -
 .../org/apache/druid/guice/ConfigModule.java  |  10 --
 .../apache/druid/guice/ConfigProvider.java    |  87 -------------
 .../druid/guice/DruidSecondaryModule.java     |   5 -
 .../druid/guice/StartupInjectorBuilder.java   |  45 +++++++
 .../druid/java/util/common/config/Config.java |  36 ------
 .../util/common/config/DurationCoercible.java |  47 -------
 .../guice/StartupInjectorBuilderTest.java     |  60 +++++++++
 server/pom.xml                                |   4 -
 ...LegacyBrokerParallelMergeConfigModule.java |  42 ------
 .../query/BrokerParallelMergeConfig.java      | 120 ++++--------------
 .../LegacyBrokerParallelMergeConfig.java      |  74 -----------
 .../guice/BrokerProcessingModuleTest.java     |  21 ---
 .../druid/guice/QueryableModuleTest.java      |   1 -
 .../java/org/apache/druid/cli/CliBroker.java  |   2 -
 29 files changed, 143 insertions(+), 486 deletions(-)
 delete mode 100644 processing/src/main/java/org/apache/druid/guice/ConfigProvider.java
 delete mode 100644 processing/src/main/java/org/apache/druid/java/util/common/config/Config.java
 delete mode 100644 processing/src/main/java/org/apache/druid/java/util/common/config/DurationCoercible.java
 delete mode 100644 server/src/main/java/org/apache/druid/guice/LegacyBrokerParallelMergeConfigModule.java
 delete mode 100644 server/src/main/java/org/apache/druid/query/LegacyBrokerParallelMergeConfig.java

diff --git a/docs/configuration/index.md b/docs/configuration/index.md
index cd1b8dfc1f9e..0ed82017c3dd 100644
--- a/docs/configuration/index.md
+++ b/docs/configuration/index.md
@@ -1908,12 +1908,12 @@ The broker uses processing configs for nested groupBy queries.
 |`druid.processing.fifo`|If the processing queue should treat tasks of equal priority in a FIFO manner|`true`|
 |`druid.processing.tmpDir`|Path where temporary files created while processing a query should be stored. If specified, this configuration takes priority over the default `java.io.tmpdir` path.|path represented by `java.io.tmpdir`|
 |`druid.processing.merge.useParallelMergePool`|Enable automatic parallel merging for Brokers on a dedicated async ForkJoinPool. If `false`, instead merges will be done serially on the `HTTP` thread pool.|`true`|
-|`druid.processing.merge.pool.parallelism`|Size of ForkJoinPool. Note that the default configuration assumes that the value returned by `Runtime.getRuntime().availableProcessors()` represents 2 hyper-threads per physical core, and multiplies this value by `0.75` in attempt to size `1.5` times the number of _physical_ cores.|`Runtime.getRuntime().availableProcessors() * 0.75` (rounded up)|
-|`druid.processing.merge.pool.defaultMaxQueryParallelism`|Default maximum number of parallel merge tasks per query. Note that the default configuration assumes that the value returned by `Runtime.getRuntime().availableProcessors()` represents 2 hyper-threads per physical core, and multiplies this value by `0.5` in attempt to size to the number of _physical_ cores.|`Runtime.getRuntime().availableProcessors() * 0.5` (rounded up)|
-|`druid.processing.merge.pool.awaitShutdownMillis`|Time to wait for merge ForkJoinPool tasks to complete before ungracefully stopping on process shutdown in milliseconds.|`60_000`|
-|`druid.processing.merge.task.targetRunTimeMillis`|Ideal run-time of each ForkJoinPool merge task, before forking off a new task to continue merging sequences.|100|
-|`druid.processing.merge.task.initialYieldNumRows`|Number of rows to yield per ForkJoinPool merge task, before forking off a new task to continue merging sequences.|16384|
-|`druid.processing.merge.task.smallBatchNumRows`|Size of result batches to operate on in ForkJoinPool merge tasks.|4096|
+|`druid.processing.merge.parallelism`|Size of ForkJoinPool. Note that the default configuration assumes that the value returned by `Runtime.getRuntime().availableProcessors()` represents 2 hyper-threads per physical core, and multiplies this value by `0.75` in attempt to size `1.5` times the number of _physical_ cores.|`Runtime.getRuntime().availableProcessors() * 0.75` (rounded up)|
+|`druid.processing.merge.defaultMaxQueryParallelism`|Default maximum number of parallel merge tasks per query. Note that the default configuration assumes that the value returned by `Runtime.getRuntime().availableProcessors()` represents 2 hyper-threads per physical core, and multiplies this value by `0.5` in attempt to size to the number of _physical_ cores.|`Runtime.getRuntime().availableProcessors() * 0.5` (rounded up)|
+|`druid.processing.merge.awaitShutdownMillis`|Time to wait for merge ForkJoinPool tasks to complete before ungracefully stopping on process shutdown in milliseconds.|`60_000`|
+|`druid.processing.merge.targetRunTimeMillis`|Ideal run-time of each ForkJoinPool merge task, before forking off a new task to continue merging sequences.|100|
+|`druid.processing.merge.initialYieldNumRows`|Number of rows to yield per ForkJoinPool merge task, before forking off a new task to continue merging sequences.|16384|
+|`druid.processing.merge.smallBatchNumRows`|Size of result batches to operate on in ForkJoinPool merge tasks.|4096|
 
 The amount of direct memory needed by Druid is at least
 `druid.processing.buffer.sizeBytes * (druid.processing.numMergeBuffers + 1)`. You can
diff --git a/docs/configuration/logging.md b/docs/configuration/logging.md
index 0764ffcf862e..36b3492bb9e0 100644
--- a/docs/configuration/logging.md
+++ b/docs/configuration/logging.md
@@ -95,9 +95,6 @@ The following example log4j2.xml is based upon the micro quickstart:
     </Logger>
 
     <!-- Quieter logging at startup -->
-    <Logger name="org.skife.config" level="warn" additivity="false">
-      <Appender-ref ref="FileAppender"/>
-    </Logger>
     <Logger name="com.sun.jersey.guice" level="warn" additivity="false">
       <Appender-ref ref="FileAppender"/>
     </Logger>
diff --git a/docs/querying/query-context.md b/docs/querying/query-context.md
index d5ddea04f27d..f62c7f8334f6 100644
--- a/docs/querying/query-context.md
+++ b/docs/querying/query-context.md
@@ -58,9 +58,9 @@ See [SQL query context](sql-query-context.md) for other query context parameters
 |`serializeDateTimeAsLong`| `false`       | If true, DateTime is serialized as long in the result returned by Broker and the data transportation between Broker and compute process|
 |`serializeDateTimeAsLongInner`| `false`  | If true, DateTime is serialized as long in the data transportation between Broker and compute process|
 |`enableParallelMerge`|`true`|Enable parallel result merging on the Broker. Note that `druid.processing.merge.useParallelMergePool` must be enabled for this setting to be set to `true`. See [Broker configuration](../configuration/index.md#broker) for more details.|
-|`parallelMergeParallelism`|`druid.processing.merge.pool.parallelism`|Maximum number of parallel threads to use for parallel result merging on the Broker. See [Broker configuration](../configuration/index.md#broker) for more details.|
-|`parallelMergeInitialYieldRows`|`druid.processing.merge.task.initialYieldNumRows`|Number of rows to yield per ForkJoinPool merge task for parallel result merging on the Broker, before forking off a new task to continue merging sequences. See [Broker configuration](../configuration/index.md#broker) for more details.|
-|`parallelMergeSmallBatchRows`|`druid.processing.merge.task.smallBatchNumRows`|Size of result batches to operate on in ForkJoinPool merge tasks for parallel result merging on the Broker. See [Broker configuration](../configuration/index.md#broker) for more details.|
+|`parallelMergeParallelism`|`druid.processing.merge.parallelism`|Maximum number of parallel threads to use for parallel result merging on the Broker. See [Broker configuration](../configuration/index.md#broker) for more details.|
+|`parallelMergeInitialYieldRows`|`druid.processing.merge.initialYieldNumRows`|Number of rows to yield per ForkJoinPool merge task for parallel result merging on the Broker, before forking off a new task to continue merging sequences. See [Broker configuration](../configuration/index.md#broker) for more details.|
+|`parallelMergeSmallBatchRows`|`druid.processing.merge.smallBatchNumRows`|Size of result batches to operate on in ForkJoinPool merge tasks for parallel result merging on the Broker. See [Broker configuration](../configuration/index.md#broker) for more details.|
 |`useFilterCNF`|`false`| If true, Druid will attempt to convert the query filter to Conjunctive Normal Form (CNF). During query processing, columns can be pre-filtered by intersecting the bitmap indexes of all values that match the eligible filters, often greatly reducing the raw number of rows which need to be scanned. But this effect only happens for the top level filter, or individual clauses of a top level 'and' filter. As such, filters in CNF potentially have a higher chance to utilize a large amount of bitmap indexes on string columns during pre-filtering. However, this setting should be used with great caution, as it can sometimes have a negative effect on performance, and in some cases, the act of computing CNF of a filter can be expensive. We recommend hand tuning your filters to produce an optimal form if possible, or at least verifying through experimentation that using this parameter actually improves your query performance with no ill-effects.|
 |`secondaryPartitionPruning`|`true`|Enable secondary partition pruning on the Broker. The Broker will always prune unnecessary segments from the input scan based on a filter on time intervals, but if the data is further partitioned with hash or range partitioning, this option will enable additional pruning based on a filter on secondary partition dimensions.|
 |`debug`| `false` | Flag indicating whether to enable debugging outputs for the query. When set to false, no additional logs will be produced (logs produced will be entirely dependent on your logging level). When set to true, the following addition logs will be produced:<br />- Log the stack trace of the exception (if any) produced by the query |
diff --git a/examples/conf/druid/auto/_common/log4j2.xml b/examples/conf/druid/auto/_common/log4j2.xml
index eb24a2a89406..b9f456c43eef 100644
--- a/examples/conf/druid/auto/_common/log4j2.xml
+++ b/examples/conf/druid/auto/_common/log4j2.xml
@@ -76,9 +76,6 @@
     </Logger>
 
     <!-- Quieter logging at startup -->
-    <Logger name="org.skife.config" level="warn" additivity="false">
-      <Appender-ref ref="FileAppender"/>
-    </Logger>
     <Logger name="com.sun.jersey.guice" level="warn" additivity="false">
       <Appender-ref ref="FileAppender"/>
     </Logger>
diff --git a/examples/conf/druid/cluster/_common/log4j2.xml b/examples/conf/druid/cluster/_common/log4j2.xml
index eb24a2a89406..b9f456c43eef 100644
--- a/examples/conf/druid/cluster/_common/log4j2.xml
+++ b/examples/conf/druid/cluster/_common/log4j2.xml
@@ -76,9 +76,6 @@
     </Logger>
 
     <!-- Quieter logging at startup -->
-    <Logger name="org.skife.config" level="warn" additivity="false">
-      <Appender-ref ref="FileAppender"/>
-    </Logger>
     <Logger name="com.sun.jersey.guice" level="warn" additivity="false">
       <Appender-ref ref="FileAppender"/>
     </Logger>
diff --git a/examples/conf/druid/single-server/large/_common/log4j2.xml b/examples/conf/druid/single-server/large/_common/log4j2.xml
index eb24a2a89406..b9f456c43eef 100644
--- a/examples/conf/druid/single-server/large/_common/log4j2.xml
+++ b/examples/conf/druid/single-server/large/_common/log4j2.xml
@@ -76,9 +76,6 @@
     </Logger>
 
     <!-- Quieter logging at startup -->
-    <Logger name="org.skife.config" level="warn" additivity="false">
-      <Appender-ref ref="FileAppender"/>
-    </Logger>
     <Logger name="com.sun.jersey.guice" level="warn" additivity="false">
       <Appender-ref ref="FileAppender"/>
     </Logger>
diff --git a/examples/conf/druid/single-server/medium/_common/log4j2.xml b/examples/conf/druid/single-server/medium/_common/log4j2.xml
index eb24a2a89406..b9f456c43eef 100644
--- a/examples/conf/druid/single-server/medium/_common/log4j2.xml
+++ b/examples/conf/druid/single-server/medium/_common/log4j2.xml
@@ -76,9 +76,6 @@
     </Logger>
 
     <!-- Quieter logging at startup -->
-    <Logger name="org.skife.config" level="warn" additivity="false">
-      <Appender-ref ref="FileAppender"/>
-    </Logger>
     <Logger name="com.sun.jersey.guice" level="warn" additivity="false">
       <Appender-ref ref="FileAppender"/>
     </Logger>
diff --git a/examples/conf/druid/single-server/micro-quickstart/_common/log4j2.xml b/examples/conf/druid/single-server/micro-quickstart/_common/log4j2.xml
index eb24a2a89406..b9f456c43eef 100644
--- a/examples/conf/druid/single-server/micro-quickstart/_common/log4j2.xml
+++ b/examples/conf/druid/single-server/micro-quickstart/_common/log4j2.xml
@@ -76,9 +76,6 @@
     </Logger>
 
     <!-- Quieter logging at startup -->
-    <Logger name="org.skife.config" level="warn" additivity="false">
-      <Appender-ref ref="FileAppender"/>
-    </Logger>
     <Logger name="com.sun.jersey.guice" level="warn" additivity="false">
       <Appender-ref ref="FileAppender"/>
     </Logger>
diff --git a/examples/conf/druid/single-server/nano-quickstart/_common/log4j2.xml b/examples/conf/druid/single-server/nano-quickstart/_common/log4j2.xml
index eb24a2a89406..b9f456c43eef 100644
--- a/examples/conf/druid/single-server/nano-quickstart/_common/log4j2.xml
+++ b/examples/conf/druid/single-server/nano-quickstart/_common/log4j2.xml
@@ -76,9 +76,6 @@
     </Logger>
 
     <!-- Quieter logging at startup -->
-    <Logger name="org.skife.config" level="warn" additivity="false">
-      <Appender-ref ref="FileAppender"/>
-    </Logger>
     <Logger name="com.sun.jersey.guice" level="warn" additivity="false">
       <Appender-ref ref="FileAppender"/>
     </Logger>
diff --git a/examples/conf/druid/single-server/small/_common/log4j2.xml b/examples/conf/druid/single-server/small/_common/log4j2.xml
index eb24a2a89406..b9f456c43eef 100644
--- a/examples/conf/druid/single-server/small/_common/log4j2.xml
+++ b/examples/conf/druid/single-server/small/_common/log4j2.xml
@@ -76,9 +76,6 @@
     </Logger>
 
     <!-- Quieter logging at startup -->
-    <Logger name="org.skife.config" level="warn" additivity="false">
-      <Appender-ref ref="FileAppender"/>
-    </Logger>
     <Logger name="com.sun.jersey.guice" level="warn" additivity="false">
       <Appender-ref ref="FileAppender"/>
     </Logger>
diff --git a/examples/conf/druid/single-server/xlarge/_common/log4j2.xml b/examples/conf/druid/single-server/xlarge/_common/log4j2.xml
index eb24a2a89406..b9f456c43eef 100644
--- a/examples/conf/druid/single-server/xlarge/_common/log4j2.xml
+++ b/examples/conf/druid/single-server/xlarge/_common/log4j2.xml
@@ -76,9 +76,6 @@
     </Logger>
 
     <!-- Quieter logging at startup -->
-    <Logger name="org.skife.config" level="warn" additivity="false">
-      <Appender-ref ref="FileAppender"/>
-    </Logger>
     <Logger name="com.sun.jersey.guice" level="warn" additivity="false">
       <Appender-ref ref="FileAppender"/>
     </Logger>
diff --git a/integration-tests-ex/cases/src/test/java/org/apache/druid/testsEx/config/Initializer.java b/integration-tests-ex/cases/src/test/java/org/apache/druid/testsEx/config/Initializer.java
index d420b65dd8df..200cfad17c70 100644
--- a/integration-tests-ex/cases/src/test/java/org/apache/druid/testsEx/config/Initializer.java
+++ b/integration-tests-ex/cases/src/test/java/org/apache/druid/testsEx/config/Initializer.java
@@ -35,9 +35,9 @@
 import org.apache.druid.discovery.DruidNodeDiscoveryProvider;
 import org.apache.druid.discovery.NodeRole;
 import org.apache.druid.guice.AnnouncerModule;
+import org.apache.druid.guice.BrokerProcessingModule;
 import org.apache.druid.guice.JsonConfigProvider;
 import org.apache.druid.guice.LazySingleton;
-import org.apache.druid.guice.LegacyBrokerParallelMergeConfigModule;
 import org.apache.druid.guice.ManageLifecycle;
 import org.apache.druid.guice.PolyBind;
 import org.apache.druid.guice.SQLMetadataStorageDruidModule;
@@ -508,8 +508,7 @@ private static Injector makeInjector(
             new AnnouncerModule(),
             new DiscoveryModule(),
             // Dependencies from other modules
-            new LegacyBrokerParallelMergeConfigModule(),
-            // Dependencies from other modules
+            new BrokerProcessingModule(),
             new StorageNodeModule(),
             new MSQExternalDataSourceModule(),
 
diff --git a/licenses.yaml b/licenses.yaml
index b72b819d79e4..8f46132a18fe 100644
--- a/licenses.yaml
+++ b/licenses.yaml
@@ -2493,16 +2493,6 @@ libraries:
 
 ---
 
-name: Config Magic
-license_category: binary
-module: java-core
-license_name: Apache License version 2.0
-version: 0.9
-libraries:
-  - org.skife.config: config-magic
-
----
-
 name: Apache Hadoop
 license_category: binary
 module: hadoop-client
diff --git a/pom.xml b/pom.xml
index 797f3447143a..35261750755b 100644
--- a/pom.xml
+++ b/pom.xml
@@ -388,17 +388,6 @@
                 <artifactId>airline</artifactId>
                 <version>2.8.4</version>
             </dependency>
-            <dependency>
-                <groupId>org.skife.config</groupId>
-                <artifactId>config-magic</artifactId>
-                <version>0.9</version>
-                <exclusions>
-                    <exclusion>
-                        <groupId>org.slf4j</groupId>
-                        <artifactId>slf4j-api</artifactId>
-                    </exclusion>
-                </exclusions>
-            </dependency>
             <dependency>
                 <groupId>net.minidev</groupId>
                 <artifactId>json-smart</artifactId>
diff --git a/processing/pom.xml b/processing/pom.xml
index 0549bc53cfda..bc875dba9e95 100644
--- a/processing/pom.xml
+++ b/processing/pom.xml
@@ -65,10 +65,6 @@
       <groupId>com.fasterxml.jackson.dataformat</groupId>
       <artifactId>jackson-dataformat-smile</artifactId>
     </dependency>
-    <dependency>
-      <groupId>org.skife.config</groupId>
-      <artifactId>config-magic</artifactId>
-    </dependency>
     <dependency>
       <groupId>commons-io</groupId>
       <artifactId>commons-io</artifactId>
diff --git a/processing/src/main/java/org/apache/druid/guice/ConfigModule.java b/processing/src/main/java/org/apache/druid/guice/ConfigModule.java
index 522ee63337e4..835999e634b2 100644
--- a/processing/src/main/java/org/apache/druid/guice/ConfigModule.java
+++ b/processing/src/main/java/org/apache/druid/guice/ConfigModule.java
@@ -21,13 +21,9 @@
 
 import com.google.inject.Binder;
 import com.google.inject.Module;
-import com.google.inject.Provides;
-import org.apache.druid.java.util.common.config.Config;
-import org.skife.config.ConfigurationObjectFactory;
 
 import javax.validation.Validation;
 import javax.validation.Validator;
-import java.util.Properties;
 
 /**
  */
@@ -39,10 +35,4 @@ public void configure(Binder binder)
     binder.bind(Validator.class).toInstance(Validation.buildDefaultValidatorFactory().getValidator());
     binder.bind(JsonConfigurator.class).in(LazySingleton.class);
   }
-
-  @Provides @LazySingleton
-  public ConfigurationObjectFactory makeFactory(Properties props)
-  {
-    return Config.createFactory(props);
-  }
 }
diff --git a/processing/src/main/java/org/apache/druid/guice/ConfigProvider.java b/processing/src/main/java/org/apache/druid/guice/ConfigProvider.java
deleted file mode 100644
index 682dce0f7cb4..000000000000
--- a/processing/src/main/java/org/apache/druid/guice/ConfigProvider.java
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.apache.druid.guice;
-
-import com.google.common.base.Preconditions;
-import com.google.inject.Binder;
-import com.google.inject.Inject;
-import com.google.inject.Provider;
-import org.apache.druid.java.util.common.logger.Logger;
-import org.skife.config.ConfigurationObjectFactory;
-
-import java.util.Map;
-
-/**
- *
- */
-@Deprecated
-public class ConfigProvider<T> implements Provider<T>
-{
-  private static final Logger log = new Logger(ConfigProvider.class);
-
-  public static <T> void bind(Binder binder, Class<T> clazz)
-  {
-    binder.bind(clazz).toProvider(of(clazz)).in(LazySingleton.class);
-  }
-
-  public static <T> Provider<T> of(Class<T> clazz)
-  {
-    return of(clazz, null);
-  }
-
-  public static <T> Provider<T> of(Class<T> clazz, Map<String, String> replacements)
-  {
-    return new ConfigProvider<>(clazz, replacements);
-  }
-
-  private final Class<T> clazz;
-  private final Map<String, String> replacements;
-
-  private ConfigurationObjectFactory factory = null;
-
-  public ConfigProvider(
-      Class<T> clazz,
-      Map<String, String> replacements
-  )
-  {
-    this.clazz = clazz;
-    this.replacements = replacements;
-  }
-
-  @Inject
-  public void inject(ConfigurationObjectFactory factory)
-  {
-    this.factory = factory;
-  }
-
-  @Override
-  public T get()
-  {
-    try {
-      // ConfigMagic handles a null replacements
-      Preconditions.checkNotNull(factory, "Code misconfigured, inject() didn't get called.");
-      return factory.buildWithReplacements(clazz, replacements);
-    }
-    catch (IllegalArgumentException e) {
-      log.info("Unable to build instance of class[%s]", clazz);
-      throw e;
-    }
-  }
-}
diff --git a/processing/src/main/java/org/apache/druid/guice/DruidSecondaryModule.java b/processing/src/main/java/org/apache/druid/guice/DruidSecondaryModule.java
index a22ef051457b..be0ea786f58e 100644
--- a/processing/src/main/java/org/apache/druid/guice/DruidSecondaryModule.java
+++ b/processing/src/main/java/org/apache/druid/guice/DruidSecondaryModule.java
@@ -31,7 +31,6 @@
 import org.apache.druid.guice.annotations.Json;
 import org.apache.druid.guice.annotations.JsonNonNull;
 import org.apache.druid.guice.annotations.Smile;
-import org.skife.config.ConfigurationObjectFactory;
 
 import javax.validation.Validator;
 import java.util.Properties;
@@ -40,7 +39,6 @@
 public class DruidSecondaryModule implements Module
 {
   private final Properties properties;
-  private final ConfigurationObjectFactory factory;
   private final ObjectMapper jsonMapper;
   private final ObjectMapper jsonMapperOnlyNonNullValueSerialization;
   private final ObjectMapper smileMapper;
@@ -49,7 +47,6 @@ public class DruidSecondaryModule implements Module
   @Inject
   public DruidSecondaryModule(
       Properties properties,
-      ConfigurationObjectFactory factory,
       @Json ObjectMapper jsonMapper,
       @JsonNonNull ObjectMapper jsonMapperOnlyNonNullValueSerialization,
       @Smile ObjectMapper smileMapper,
@@ -57,7 +54,6 @@ public DruidSecondaryModule(
   )
   {
     this.properties = properties;
-    this.factory = factory;
     this.jsonMapper = jsonMapper;
     this.jsonMapperOnlyNonNullValueSerialization = jsonMapperOnlyNonNullValueSerialization;
     this.smileMapper = smileMapper;
@@ -69,7 +65,6 @@ public void configure(Binder binder)
   {
     binder.install(new DruidGuiceExtensions());
     binder.bind(Properties.class).toInstance(properties);
-    binder.bind(ConfigurationObjectFactory.class).toInstance(factory);
     binder.bind(ObjectMapper.class).to(Key.get(ObjectMapper.class, Json.class));
     binder.bind(Validator.class).toInstance(validator);
     binder.bind(JsonConfigurator.class);
diff --git a/processing/src/main/java/org/apache/druid/guice/StartupInjectorBuilder.java b/processing/src/main/java/org/apache/druid/guice/StartupInjectorBuilder.java
index bdf73993efac..1d524a9a1e79 100644
--- a/processing/src/main/java/org/apache/druid/guice/StartupInjectorBuilder.java
+++ b/processing/src/main/java/org/apache/druid/guice/StartupInjectorBuilder.java
@@ -165,6 +165,51 @@ public void validate()
             docsLink
         );
       }
+
+      validateRemovedProcessingConfigs();
+    }
+
+    private void validateRemovedProcessingConfigs()
+    {
+      checkDeletedConfigAndThrow(
+          "druid.processing.merge.task.initialYieldNumRows",
+          "druid.processing.merge.initialYieldNumRows"
+      );
+      checkDeletedConfigAndThrow(
+          "druid.processing.merge.task.targetRunTimeMillis",
+          "druid.processing.merge.targetRunTimeMillis"
+      );
+      checkDeletedConfigAndThrow(
+          "druid.processing.merge.task.smallBatchNumRows",
+          "druid.processing.merge.smallBatchNumRows"
+      );
+
+      checkDeletedConfigAndThrow(
+          "druid.processing.merge.pool.awaitShutdownMillis",
+          "druid.processing.merge.awaitShutdownMillis"
+      );
+      checkDeletedConfigAndThrow(
+          "druid.processing.merge.pool.parallelism",
+          "druid.processing.merge.parallelism"
+      );
+      checkDeletedConfigAndThrow(
+          "druid.processing.merge.pool.defaultMaxQueryParallelism",
+          "druid.processing.merge.defaultMaxQueryParallelism"
+      );
+    }
+
+    /**
+     * Checks if a deleted config is present in the properties and throws an ISE.
+     */
+    private void checkDeletedConfigAndThrow(String deletedConfigName, String replaceConfigName)
+    {
+      if (properties.getProperty(deletedConfigName) != null) {
+        throw new ISE(
+            "Config[%s] has been removed. Please use config[%s] instead.",
+            deletedConfigName,
+            replaceConfigName
+        );
+      }
     }
   }
 
diff --git a/processing/src/main/java/org/apache/druid/java/util/common/config/Config.java b/processing/src/main/java/org/apache/druid/java/util/common/config/Config.java
deleted file mode 100644
index e5a7c96275f0..000000000000
--- a/processing/src/main/java/org/apache/druid/java/util/common/config/Config.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.apache.druid.java.util.common.config;
-
-import org.skife.config.ConfigurationObjectFactory;
-
-import java.util.Properties;
-
-/**
-*/
-public class Config
-{
-  public static ConfigurationObjectFactory createFactory(Properties props)
-  {
-    ConfigurationObjectFactory configFactory = new ConfigurationObjectFactory(props);
-    configFactory.addCoercible(new DurationCoercible());
-    return configFactory;
-  }
-}
diff --git a/processing/src/main/java/org/apache/druid/java/util/common/config/DurationCoercible.java b/processing/src/main/java/org/apache/druid/java/util/common/config/DurationCoercible.java
deleted file mode 100644
index 5ba543bbfc08..000000000000
--- a/processing/src/main/java/org/apache/druid/java/util/common/config/DurationCoercible.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.apache.druid.java.util.common.config;
-
-import org.joda.time.Duration;
-import org.joda.time.Period;
-import org.skife.config.Coercer;
-import org.skife.config.Coercible;
-
-/**
-*/
-public class DurationCoercible implements Coercible<Duration>
-{
-  @Override
-  public Coercer<Duration> accept(Class<?> clazz)
-  {
-    if (Duration.class != clazz) {
-      return null;
-    }
-
-    return new Coercer<>()
-    {
-      @Override
-      public Duration coerce(String value)
-      {
-        return new Period(value).toStandardDuration();
-      }
-    };
-  }
-}
diff --git a/processing/src/test/java/org/apache/druid/guice/StartupInjectorBuilderTest.java b/processing/src/test/java/org/apache/druid/guice/StartupInjectorBuilderTest.java
index 892434defcee..bcf85742c2ac 100644
--- a/processing/src/test/java/org/apache/druid/guice/StartupInjectorBuilderTest.java
+++ b/processing/src/test/java/org/apache/druid/guice/StartupInjectorBuilderTest.java
@@ -21,10 +21,12 @@
 
 import com.google.inject.Injector;
 import org.apache.druid.common.config.NullValueHandlingConfig;
+import org.apache.druid.error.ExceptionMatcher;
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.math.expr.ExpressionProcessingConfig;
 import org.apache.druid.utils.RuntimeInfo;
+import org.hamcrest.MatcherAssert;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -194,4 +196,62 @@ public void testValidator()
         t.getMessage()
     );
   }
+
+  @Test
+  public void verifyInjectorBuild_withDeletedConfig_throwsException()
+  {
+    verifyInjectorBuild_withDeletedConfig_throwsException(
+        "druid.processing.merge.pool.parallelism",
+        "10",
+        "Config[druid.processing.merge.pool.parallelism] has been removed."
+        + " Please use config[druid.processing.merge.parallelism] instead."
+    );
+    verifyInjectorBuild_withDeletedConfig_throwsException(
+        "druid.processing.merge.pool.awaitShutdownMillis",
+        "1000",
+        "Config[druid.processing.merge.pool.awaitShutdownMillis] has been removed."
+        + " Please use config[druid.processing.merge.awaitShutdownMillis] instead."
+    );
+    verifyInjectorBuild_withDeletedConfig_throwsException(
+        "druid.processing.merge.pool.defaultMaxQueryParallelism",
+        "100",
+        "Config[druid.processing.merge.pool.defaultMaxQueryParallelism] has been removed."
+        + " Please use config[druid.processing.merge.defaultMaxQueryParallelism] instead."
+    );
+
+    verifyInjectorBuild_withDeletedConfig_throwsException(
+        "druid.processing.merge.task.targetRunTimeMillis",
+        "10",
+        "Config[druid.processing.merge.task.targetRunTimeMillis] has been removed."
+        + " Please use config[druid.processing.merge.targetRunTimeMillis] instead."
+    );
+    verifyInjectorBuild_withDeletedConfig_throwsException(
+        "druid.processing.merge.task.initialYieldNumRows",
+        "1000",
+        "Config[druid.processing.merge.task.initialYieldNumRows] has been removed."
+        + " Please use config[druid.processing.merge.initialYieldNumRows] instead."
+    );
+    verifyInjectorBuild_withDeletedConfig_throwsException(
+        "druid.processing.merge.task.smallBatchNumRows",
+        "100",
+        "Config[druid.processing.merge.task.smallBatchNumRows] has been removed."
+        + " Please use config[druid.processing.merge.smallBatchNumRows] instead."
+    );
+  }
+
+  private static void verifyInjectorBuild_withDeletedConfig_throwsException(
+      String removedProperty,
+      String dummyValue,
+      String expectedMessage
+  )
+  {
+    final Properties props = new Properties();
+    props.setProperty(removedProperty, dummyValue);
+
+    final StartupInjectorBuilder builder = new StartupInjectorBuilder().withExtensions().withProperties(props);
+    MatcherAssert.assertThat(
+        Assert.assertThrows(ISE.class, builder::build),
+        ExceptionMatcher.of(ISE.class).expectMessageIs(expectedMessage)
+    );
+  }
 }
diff --git a/server/pom.xml b/server/pom.xml
index edc8c558db13..026595361f1d 100644
--- a/server/pom.xml
+++ b/server/pom.xml
@@ -254,10 +254,6 @@
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>
         </dependency>
-        <dependency>
-            <groupId>org.skife.config</groupId>
-            <artifactId>config-magic</artifactId>
-        </dependency>
         <dependency>
             <groupId>org.apache.curator</groupId>
             <artifactId>curator-recipes</artifactId>
diff --git a/server/src/main/java/org/apache/druid/guice/LegacyBrokerParallelMergeConfigModule.java b/server/src/main/java/org/apache/druid/guice/LegacyBrokerParallelMergeConfigModule.java
deleted file mode 100644
index 3d44cf23f72b..000000000000
--- a/server/src/main/java/org/apache/druid/guice/LegacyBrokerParallelMergeConfigModule.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.apache.druid.guice;
-
-import com.google.inject.Binder;
-import com.google.inject.Module;
-import org.apache.druid.query.LegacyBrokerParallelMergeConfig;
-
-/**
- * Backwards compatibility for runtime.properties for Druid 27 and older to make deprecated config paths of
- * {@link LegacyBrokerParallelMergeConfig} still work for Druid 28.
- * {@link org.apache.druid.query.BrokerParallelMergeConfig} has replaced these configs, and will warn when these
- * deprecated paths are configured. This module should be removed in Druid 29, along with
- * {@link LegacyBrokerParallelMergeConfig} as well as the config-magic library that makes it work.
- */
-@Deprecated
-public class LegacyBrokerParallelMergeConfigModule implements Module
-{
-
-  @Override
-  public void configure(Binder binder)
-  {
-    ConfigProvider.bind(binder, LegacyBrokerParallelMergeConfig.class);
-  }
-}
diff --git a/server/src/main/java/org/apache/druid/query/BrokerParallelMergeConfig.java b/server/src/main/java/org/apache/druid/query/BrokerParallelMergeConfig.java
index 1f8d25a10c2d..a7f0123c155a 100644
--- a/server/src/main/java/org/apache/druid/query/BrokerParallelMergeConfig.java
+++ b/server/src/main/java/org/apache/druid/query/BrokerParallelMergeConfig.java
@@ -19,10 +19,10 @@
 
 package org.apache.druid.query;
 
-import com.fasterxml.jackson.annotation.JacksonInject;
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.annotations.VisibleForTesting;
+import org.apache.druid.common.config.Configs;
 import org.apache.druid.java.util.common.guava.ParallelMergeCombiningSequence;
 import org.apache.druid.java.util.common.logger.Logger;
 import org.apache.druid.utils.JvmUtils;
@@ -57,25 +57,15 @@ public BrokerParallelMergeConfig(
       @JsonProperty("defaultMaxQueryParallelism") @Nullable Integer defaultMaxQueryParallelism,
       @JsonProperty("targetRunTimeMillis") @Nullable Integer targetRunTimeMillis,
       @JsonProperty("initialYieldNumRows") @Nullable Integer initialYieldNumRows,
-      @JsonProperty("smallBatchNumRows") @Nullable Integer smallBatchNumRows,
-      @JacksonInject LegacyBrokerParallelMergeConfig oldConfig
+      @JsonProperty("smallBatchNumRows") @Nullable Integer smallBatchNumRows
   )
   {
-    if (parallelism == null) {
-      if (oldConfig == null || oldConfig.getMergePoolParallelism() == null) {
+    this.parallelism = Configs.valueOrDefault(
+        parallelism,
         // assume 2 hyper-threads per core, so that this value is probably by default the number
         // of physical cores * 1.5
-        this.parallelism = (int) Math.ceil(JvmUtils.getRuntimeInfo().getAvailableProcessors() * 0.75);
-      } else {
-        warnDeprecated(
-            "druid.processing.merge.pool.parallelism",
-            "druid.processing.merge.parallelism"
-        );
-        this.parallelism = oldConfig.getMergePoolParallelism();
-      }
-    } else {
-      this.parallelism = parallelism;
-    }
+        (int) Math.ceil(JvmUtils.getRuntimeInfo().getAvailableProcessors() * 0.75)
+    );
 
     // need at least 3 to do 2 layer merge
     if (this.parallelism > 2) {
@@ -90,81 +80,36 @@ public BrokerParallelMergeConfig(
       this.useParallelMergePool = false;
     }
 
-    if (awaitShutdownMillis == null) {
-      if (oldConfig == null || oldConfig.getMergePoolAwaitShutdownMillis() == null) {
-        this.awaitShutdownMillis = DEFAULT_MERGE_POOL_AWAIT_SHUTDOWN_MILLIS;
-      } else {
-        warnDeprecated(
-            "druid.processing.merge.pool.awaitShutdownMillis",
-            "druid.processing.merge.awaitShutdownMillis"
-        );
-        this.awaitShutdownMillis = oldConfig.getMergePoolAwaitShutdownMillis();
-      }
-    } else {
-      this.awaitShutdownMillis = awaitShutdownMillis;
-    }
+    this.awaitShutdownMillis = Configs.valueOrDefault(
+        awaitShutdownMillis,
+        DEFAULT_MERGE_POOL_AWAIT_SHUTDOWN_MILLIS
+    );
 
-    if (defaultMaxQueryParallelism == null) {
-      if (oldConfig == null || oldConfig.getMergePoolDefaultMaxQueryParallelism() == null) {
-        this.defaultMaxQueryParallelism = (int) Math.max(JvmUtils.getRuntimeInfo().getAvailableProcessors() * 0.5, 1);
-      } else {
-        warnDeprecated(
-            "druid.processing.merge.pool.defaultMaxQueryParallelism",
-            "druid.processing.merge.defaultMaxQueryParallelism"
-        );
-        this.defaultMaxQueryParallelism = oldConfig.getMergePoolDefaultMaxQueryParallelism();
-      }
-    } else {
-      this.defaultMaxQueryParallelism = defaultMaxQueryParallelism;
-    }
+    this.defaultMaxQueryParallelism = Configs.valueOrDefault(
+        defaultMaxQueryParallelism,
+        (int) Math.max(JvmUtils.getRuntimeInfo().getAvailableProcessors() * 0.5, 1)
+    );
 
-    if (targetRunTimeMillis == null) {
-      if (oldConfig == null || oldConfig.getMergePoolTargetTaskRunTimeMillis() == null) {
-        this.targetRunTimeMillis = ParallelMergeCombiningSequence.DEFAULT_TASK_TARGET_RUN_TIME_MILLIS;
-      } else {
-        warnDeprecated(
-            "druid.processing.merge.task.targetRunTimeMillis",
-            "druid.processing.merge.targetRunTimeMillis"
-        );
-        this.targetRunTimeMillis = oldConfig.getMergePoolTargetTaskRunTimeMillis();
-      }
-    } else {
-      this.targetRunTimeMillis = targetRunTimeMillis;
-    }
+    this.targetRunTimeMillis = Configs.valueOrDefault(
+        targetRunTimeMillis,
+        ParallelMergeCombiningSequence.DEFAULT_TASK_TARGET_RUN_TIME_MILLIS
+    );
 
-    if (initialYieldNumRows == null) {
-      if (oldConfig == null || oldConfig.getMergePoolTaskInitialYieldRows() == null) {
-        this.initialYieldNumRows = ParallelMergeCombiningSequence.DEFAULT_TASK_INITIAL_YIELD_NUM_ROWS;
-      } else {
-        warnDeprecated(
-            "druid.processing.merge.task.initialYieldNumRows",
-            "druid.processing.merge.initialYieldNumRows"
-        );
-        this.initialYieldNumRows = oldConfig.getMergePoolTaskInitialYieldRows();
-      }
-    } else {
-      this.initialYieldNumRows = initialYieldNumRows;
-    }
+    this.initialYieldNumRows = Configs.valueOrDefault(
+        initialYieldNumRows,
+        ParallelMergeCombiningSequence.DEFAULT_TASK_INITIAL_YIELD_NUM_ROWS
+    );
 
-    if (smallBatchNumRows == null) {
-      if (oldConfig == null || oldConfig.getMergePoolSmallBatchRows() == null) {
-        this.smallBatchNumRows = ParallelMergeCombiningSequence.DEFAULT_TASK_SMALL_BATCH_NUM_ROWS;
-      } else {
-        warnDeprecated(
-            "druid.processing.merge.task.smallBatchNumRows",
-            "druid.processing.merge.smallBatchNumRows"
-        );
-        this.smallBatchNumRows = oldConfig.getMergePoolSmallBatchRows();
-      }
-    } else {
-      this.smallBatchNumRows = smallBatchNumRows;
-    }
+    this.smallBatchNumRows = Configs.valueOrDefault(
+        smallBatchNumRows,
+        ParallelMergeCombiningSequence.DEFAULT_TASK_SMALL_BATCH_NUM_ROWS
+    );
   }
 
   @VisibleForTesting
   public BrokerParallelMergeConfig()
   {
-    this(null, null, null, null, null, null, null, null);
+    this(null, null, null, null, null, null, null);
   }
 
   public boolean useParallelMergePool()
@@ -201,15 +146,4 @@ public int getSmallBatchNumRows()
   {
     return smallBatchNumRows;
   }
-
-  private static void warnDeprecated(String oldPath, String newPath)
-  {
-    LOG.warn(
-        "Using deprecated config [%s] which has been replace by [%s]. This path is deprecated and will be "
-        + "removed in a future release, please transition to using [%s]",
-        oldPath,
-        newPath,
-        newPath
-    );
-  }
 }
diff --git a/server/src/main/java/org/apache/druid/query/LegacyBrokerParallelMergeConfig.java b/server/src/main/java/org/apache/druid/query/LegacyBrokerParallelMergeConfig.java
deleted file mode 100644
index 25b11ab63d17..000000000000
--- a/server/src/main/java/org/apache/druid/query/LegacyBrokerParallelMergeConfig.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.apache.druid.query;
-
-import org.skife.config.Config;
-
-import javax.annotation.Nullable;
-
-/**
- * Backwards compatibility for Druid 27 and older runtime.properties configs, replaced by
- * {@link BrokerParallelMergeConfig} in Druid 28. This config should be removed in Druid 29.
- */
-@Deprecated
-public abstract class LegacyBrokerParallelMergeConfig
-{
-  @Nullable
-  @Config(value = "druid.processing.merge.pool.parallelism")
-  public Integer getMergePoolParallelism()
-  {
-    return null;
-  }
-
-  @Nullable
-  @Config(value = "druid.processing.merge.pool.awaitShutdownMillis")
-  public Long getMergePoolAwaitShutdownMillis()
-  {
-    return null;
-  }
-
-  @Nullable
-  @Config(value = "druid.processing.merge.pool.defaultMaxQueryParallelism")
-  public Integer getMergePoolDefaultMaxQueryParallelism()
-  {
-    return null;
-  }
-
-  @Nullable
-  @Config(value = "druid.processing.merge.task.targetRunTimeMillis")
-  public Integer getMergePoolTargetTaskRunTimeMillis()
-  {
-    return null;
-  }
-
-  @Nullable
-  @Config(value = "druid.processing.merge.task.initialYieldNumRows")
-  public Integer getMergePoolTaskInitialYieldRows()
-  {
-    return null;
-  }
-
-  @Nullable
-  @Config(value = "druid.processing.merge.task.smallBatchNumRows")
-  public Integer getMergePoolSmallBatchRows()
-  {
-    return null;
-  }
-}
diff --git a/server/src/test/java/org/apache/druid/guice/BrokerProcessingModuleTest.java b/server/src/test/java/org/apache/druid/guice/BrokerProcessingModuleTest.java
index 7fca81aaea30..a4bf2e282114 100644
--- a/server/src/test/java/org/apache/druid/guice/BrokerProcessingModuleTest.java
+++ b/server/src/test/java/org/apache/druid/guice/BrokerProcessingModuleTest.java
@@ -28,10 +28,8 @@
 import org.apache.druid.client.cache.CachePopulator;
 import org.apache.druid.client.cache.CachePopulatorStats;
 import org.apache.druid.initialization.Initialization;
-import org.apache.druid.java.util.common.config.Config;
 import org.apache.druid.query.BrokerParallelMergeConfig;
 import org.apache.druid.query.DruidProcessingConfig;
-import org.apache.druid.query.LegacyBrokerParallelMergeConfig;
 import org.apache.druid.utils.JvmUtils;
 import org.junit.Assert;
 import org.junit.Assume;
@@ -40,7 +38,6 @@
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
-import org.skife.config.ConfigurationObjectFactory;
 
 import java.util.Properties;
 
@@ -85,20 +82,6 @@ public void testMergeProcessingPool()
     module.getMergeProcessingPoolProvider(config);
   }
 
-  @Test
-  public void testMergeProcessingPoolLegacyConfigs()
-  {
-    Properties props = new Properties();
-    props.put("druid.processing.merge.pool.parallelism", "10");
-    props.put("druid.processing.merge.pool.defaultMaxQueryParallelism", "10");
-    props.put("druid.processing.merge.task.targetRunTimeMillis", "1000");
-    Injector gadget = makeInjector(props);
-    BrokerParallelMergeConfig config = gadget.getInstance(BrokerParallelMergeConfig.class);
-    Assert.assertEquals(10, config.getParallelism());
-    Assert.assertEquals(10, config.getDefaultMaxQueryParallelism());
-    Assert.assertEquals(1000, config.getTargetRunTimeMillis());
-  }
-
   @Test
   public void testCachePopulatorAsSingleton()
   {
@@ -138,10 +121,6 @@ private Injector makeInjector(Properties props)
                   binder.bindConstant().annotatedWith(Names.named("servicePort")).to(0);
                   binder.bindConstant().annotatedWith(Names.named("tlsServicePort")).to(-1);
                   binder.bind(Properties.class).toInstance(props);
-                  ConfigurationObjectFactory factory = Config.createFactory(props);
-                  LegacyBrokerParallelMergeConfig legacyConfig = factory.build(LegacyBrokerParallelMergeConfig.class);
-                  binder.bind(ConfigurationObjectFactory.class).toInstance(factory);
-                  binder.bind(LegacyBrokerParallelMergeConfig.class).toInstance(legacyConfig);
                 },
                 target
             ).with((binder) -> {
diff --git a/server/src/test/java/org/apache/druid/guice/QueryableModuleTest.java b/server/src/test/java/org/apache/druid/guice/QueryableModuleTest.java
index 8fad8924bf88..bc74551d60a3 100644
--- a/server/src/test/java/org/apache/druid/guice/QueryableModuleTest.java
+++ b/server/src/test/java/org/apache/druid/guice/QueryableModuleTest.java
@@ -77,7 +77,6 @@ private Injector makeInjector(Properties properties)
             new JacksonModule(),
             new ConfigModule(),
             new QueryRunnerFactoryModule(),
-            new LegacyBrokerParallelMergeConfigModule(),
             new BrokerProcessingModule(),
             new LifecycleModule(),
             binder -> binder.bind(ServiceEmitter.class).to(NoopServiceEmitter.class),
diff --git a/services/src/main/java/org/apache/druid/cli/CliBroker.java b/services/src/main/java/org/apache/druid/cli/CliBroker.java
index 09212ec75972..42bb7b51421c 100644
--- a/services/src/main/java/org/apache/druid/cli/CliBroker.java
+++ b/services/src/main/java/org/apache/druid/cli/CliBroker.java
@@ -47,7 +47,6 @@
 import org.apache.druid.guice.JoinableFactoryModule;
 import org.apache.druid.guice.JsonConfigProvider;
 import org.apache.druid.guice.LazySingleton;
-import org.apache.druid.guice.LegacyBrokerParallelMergeConfigModule;
 import org.apache.druid.guice.LifecycleModule;
 import org.apache.druid.guice.ManageLifecycle;
 import org.apache.druid.guice.QueryRunnerFactoryModule;
@@ -117,7 +116,6 @@ protected Set<NodeRole> getNodeRoles(Properties properties)
   protected List<? extends Module> getModules()
   {
     return ImmutableList.of(
-        new LegacyBrokerParallelMergeConfigModule(),
         new BrokerProcessingModule(),
         new QueryableModule(),
         new QueryRunnerFactoryModule(),

From 768cc2b8b1cc6ebbd1448a3bdbb3b01c4f217410 Mon Sep 17 00:00:00 2001
From: Misha <mikhailsviatohorof@gmail.com>
Date: Thu, 6 Mar 2025 16:57:35 +0100
Subject: [PATCH 24/99] Add field `taskLimits` to worker select strategies
 (#16889)

Changes
---------
- Add field `taskLimits` to the following worker select strategies
`equalDistribution`, `equalDistributionWithCategorySpec`, `fillCapacityWithCategorySpec`, `fillCapacity`
- Add sub-fields `maxSlotCountByType` and `maxSlotRatioByType` to `taskLimits`
- Apply these limits per worker when assigning new tasks

---------
Co-authored-by: sviatahorau <mikhail.sviatahorau@deep.bi>
Co-authored-by: Benedict Jin <asdf2014@apache.org>
Co-authored-by: Kashif Faraz <kashif.faraz@gmail.com>
---
 docs/configuration/index.md                   |  14 ++
 .../setup/WorkerBehaviorConfigTest.java       |   3 +-
 .../overlord/ImmutableWorkerInfo.java         |  28 ++-
 ...ngTaskBasedWorkerProvisioningStrategy.java |   6 +
 ...utionWithAffinityWorkerSelectStrategy.java |   5 +-
 ...nWithCategorySpecWorkerSelectStrategy.java |  21 +-
 ...EqualDistributionWorkerSelectStrategy.java |  22 +-
 ...acityWithAffinityWorkerSelectStrategy.java |   5 +-
 ...yWithCategorySpecWorkerSelectStrategy.java |  22 +-
 .../FillCapacityWorkerSelectStrategy.java     |  22 +-
 .../indexing/overlord/setup/TaskLimits.java   | 195 ++++++++++++++++++
 .../overlord/setup/WorkerBehaviorConfig.java  |   2 +-
 .../overlord/setup/WorkerSelectUtils.java     |  37 +++-
 .../overlord/ImmutableWorkerInfoTest.java     |   5 +
 .../overlord/RemoteTaskRunnerTest.java        |   2 +-
 ...dingTaskBasedProvisioningStrategyTest.java |   2 +-
 .../hrtr/HttpRemoteTaskRunnerTest.java        |   2 +-
 ...nWithAffinityWorkerSelectStrategyTest.java | 149 ++++++++++++-
 ...hCategorySpecWorkerSelectStrategyTest.java |   4 +-
 ...lDistributionWorkerSelectStrategyTest.java |  14 +-
 ...yWithAffinityWorkerSelectStrategyTest.java | 145 ++++++++++++-
 ...hCategorySpecWorkerSelectStrategyTest.java |   4 +-
 22 files changed, 660 insertions(+), 49 deletions(-)
 create mode 100644 indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/TaskLimits.java

diff --git a/docs/configuration/index.md b/docs/configuration/index.md
index 0ed82017c3dd..d75309b7ac31 100644
--- a/docs/configuration/index.md
+++ b/docs/configuration/index.md
@@ -1277,6 +1277,7 @@ This evenly distributes work across your Middle Managers.
 |--------|-----------|-------|
 |`type`|`equalDistribution`|required; must be `equalDistribution`|
 |`affinityConfig`|[`AffinityConfig`](#affinityconfig) object|null (no affinity)|
+|`taskLimits`|[`TaskLimits`](#tasklimits) object|null (no limits)|
 
 ###### `equalDistributionWithCategorySpec`
 
@@ -1288,6 +1289,7 @@ This strategy doesn't work with `AutoScaler` since the behavior is undefined.
 |--------|-----------|-------|
 |`type`|`equalDistributionWithCategorySpec`|required; must be `equalDistributionWithCategorySpec`|
 |`workerCategorySpec`|[`WorkerCategorySpec`](#workercategoryspec) object|null (no worker category spec)|
+|`taskLimits`|[`TaskLimits`](#tasklimits) object|null (no limits)|
 
 The following example shows tasks of type `index_kafka` that default to running on Middle Managers of category `c1`, except for tasks that write to datasource `ds1`, which run on Middle Managers of category `c2`.
 
@@ -1323,6 +1325,7 @@ Middle Managers up to capacity simultaneously, rather than a single Middle Manag
 |--------|-----------|-------|
 |`type`| `fillCapacity`|required; must be `fillCapacity`|
 |`affinityConfig`| [`AffinityConfig`](#affinityconfig) object |null (no affinity)|
+|`taskLimits`|[`TaskLimits`](#tasklimits) object|null (no limits)|
 
 ###### `fillCapacityWithCategorySpec`
 
@@ -1334,6 +1337,7 @@ This strategy doesn't work with `AutoScaler` since the behavior is undefined.
 |--------|-----------|-------|
 |`type`|`fillCapacityWithCategorySpec`.|required; must be `fillCapacityWithCategorySpec`|
 |`workerCategorySpec`|[`WorkerCategorySpec`](#workercategoryspec) object|null (no worker category spec)|
+|`taskLimits`|[`TaskLimits`](#tasklimits) object|null (no limits)|
 
 <a name="javascript-worker-select-strategy"></a>
 
@@ -1383,6 +1387,16 @@ field. If not provided, the default is to not use it at all.
 |`categoryMap`|A JSON map object mapping a task type String name to a [CategoryConfig](#categoryconfig) object, by which you can specify category config for different task type.|`{}`|
 |`strong`|With weak workerCategorySpec (the default), tasks for a dataSource may be assigned to other Middle Managers if the Middle Managers specified in `categoryMap` are not able to run all pending tasks in the queue for that dataSource. With strong workerCategorySpec, tasks for a dataSource will only ever be assigned to their specified Middle Managers, and will wait in the pending queue if necessary.|false|
 
+###### `taskLimits`
+
+The `taskLimits` field can be used with the `equalDistribution`, `fillCapacity`, `equalDistributionWithCategorySpec` and `fillCapacityWithCategorySpec` strategies.
+If you don't provide it, it will default to not being used.
+
+|Property|Description|Default|
+|--------|-----------|-------|
+|`maxSlotCountByType`|A map where each key is a task type (`String`), and the corresponding value represents the absolute limit on the number of task slots that tasks of this type can occupy. The value is an `Integer` that is greater than or equal to 0. For example, a value of 5 means that tasks of this type can occupy up to 5 task slots in total. If both absolute and ratio limits are specified for the same task type, the effective limit will be the smaller of the absolute limit and the limit derived from the corresponding ratio. `maxSlotCountByType = {"index_parallel": 3, "query_controller": 5}`. In this example, parallel indexing tasks can occupy up to 3 task slots, and query controllers can occupy up to 5 task slots.|`{}`|
+|`maxSlotRatioByType`|A map where each key is a task type (`String`), and the corresponding value is a `Double` which should be in the range [0, 1], representing the ratio of task slots that tasks of this type can occupy. This ratio defines the proportion of total task slots a task type can use, calculated as `ratio * totalSlots`. If both absolute and ratio limits are specified for the same task type, the effective limit will be the smaller of the absolute limit and the limit derived from the corresponding ratio. `maxSlotRatioByType = {"index_parallel": 0.5, "query_controller": 0.25}`. In this example, parallel indexing tasks can occupy up to 50% of the total task slots, and query controllers can occupy up to 25% of the total task slots.|`{}`|
+
 ###### CategoryConfig
 
 |Property|Description|Default|
diff --git a/extensions-core/ec2-extensions/src/test/java/org/apache/druid/indexing/overlord/setup/WorkerBehaviorConfigTest.java b/extensions-core/ec2-extensions/src/test/java/org/apache/druid/indexing/overlord/setup/WorkerBehaviorConfigTest.java
index a47a79fa9bc1..f777bad42e83 100644
--- a/extensions-core/ec2-extensions/src/test/java/org/apache/druid/indexing/overlord/setup/WorkerBehaviorConfigTest.java
+++ b/extensions-core/ec2-extensions/src/test/java/org/apache/druid/indexing/overlord/setup/WorkerBehaviorConfigTest.java
@@ -45,7 +45,8 @@ public void testSerde() throws Exception
             new AffinityConfig(
                 ImmutableMap.of("foo", ImmutableSet.of("localhost")),
                 false
-            )
+            ),
+            null
         ),
         new EC2AutoScaler(
             7,
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/ImmutableWorkerInfo.java b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/ImmutableWorkerInfo.java
index b1eafe0dc59d..d0a938e7022a 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/ImmutableWorkerInfo.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/ImmutableWorkerInfo.java
@@ -23,6 +23,7 @@
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.collect.ImmutableSet;
+import org.apache.druid.common.config.Configs;
 import org.apache.druid.guice.annotations.PublicApi;
 import org.apache.druid.indexing.common.task.Task;
 import org.apache.druid.indexing.common.task.TaskResource;
@@ -33,6 +34,8 @@
 
 import javax.annotation.Nullable;
 import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 
@@ -45,6 +48,7 @@ public class ImmutableWorkerInfo
   private final Worker worker;
   private final int currCapacityUsed;
   private final int currParallelIndexCapacityUsed;
+  private final Map<String, Integer> currCapacityUsedByTaskType;
   private final ImmutableSet<String> availabilityGroups;
   private final ImmutableSet<String> runningTasks;
   private final DateTime lastCompletedTaskTime;
@@ -57,6 +61,7 @@ public ImmutableWorkerInfo(
       @JsonProperty("worker") Worker worker,
       @JsonProperty("currCapacityUsed") int currCapacityUsed,
       @JsonProperty("currParallelIndexCapacityUsed") int currParallelIndexCapacityUsed,
+      @JsonProperty("currCapacityUsedByTaskType") Map<String, Integer> currCapacityUsedByTaskType,
       @JsonProperty("availabilityGroups") Set<String> availabilityGroups,
       @JsonProperty("runningTasks") Collection<String> runningTasks,
       @JsonProperty("lastCompletedTaskTime") DateTime lastCompletedTaskTime,
@@ -66,6 +71,7 @@ public ImmutableWorkerInfo(
     this.worker = worker;
     this.currCapacityUsed = currCapacityUsed;
     this.currParallelIndexCapacityUsed = currParallelIndexCapacityUsed;
+    this.currCapacityUsedByTaskType = Configs.valueOrDefault(currCapacityUsedByTaskType, Collections.emptyMap());
     this.availabilityGroups = ImmutableSet.copyOf(availabilityGroups);
     this.runningTasks = ImmutableSet.copyOf(runningTasks);
     this.lastCompletedTaskTime = lastCompletedTaskTime;
@@ -76,12 +82,13 @@ public ImmutableWorkerInfo(
       Worker worker,
       int currCapacityUsed,
       int currParallelIndexCapacityUsed,
+      Map<String, Integer> currCapacityUsedByTaskType,
       Set<String> availabilityGroups,
       Collection<String> runningTasks,
       DateTime lastCompletedTaskTime
   )
   {
-    this(worker, currCapacityUsed, currParallelIndexCapacityUsed, availabilityGroups,
+    this(worker, currCapacityUsed, currParallelIndexCapacityUsed, currCapacityUsedByTaskType, availabilityGroups,
          runningTasks, lastCompletedTaskTime, null
     );
   }
@@ -94,7 +101,7 @@ public ImmutableWorkerInfo(
       DateTime lastCompletedTaskTime
   )
   {
-    this(worker, currCapacityUsed, 0, availabilityGroups, runningTasks, lastCompletedTaskTime, null);
+    this(worker, currCapacityUsed, 0, Collections.emptyMap(), availabilityGroups, runningTasks, lastCompletedTaskTime, null);
   }
 
   /**
@@ -111,6 +118,8 @@ public static ImmutableWorkerInfo fromWorkerAnnouncements(
     int currParallelIndexCapacityUsed = 0;
     ImmutableSet.Builder<String> taskIds = ImmutableSet.builder();
     ImmutableSet.Builder<String> availabilityGroups = ImmutableSet.builder();
+    Map<String, Integer> currCapacityUsedByTaskType = new HashMap<>();
+
 
     for (final Map.Entry<String, TaskAnnouncement> entry : announcements.entrySet()) {
       final TaskAnnouncement announcement = entry.getValue();
@@ -126,6 +135,8 @@ public static ImmutableWorkerInfo fromWorkerAnnouncements(
           currParallelIndexCapacityUsed += requiredCapacity;
         }
 
+        currCapacityUsedByTaskType.merge(announcement.getTaskType(), 1, Integer::sum);
+
         taskIds.add(taskId);
         availabilityGroups.add(taskResource.getAvailabilityGroup());
       }
@@ -135,6 +146,7 @@ public static ImmutableWorkerInfo fromWorkerAnnouncements(
         worker,
         currCapacityUsed,
         currParallelIndexCapacityUsed,
+        currCapacityUsedByTaskType,
         availabilityGroups.build(),
         taskIds.build(),
         lastCompletedTaskTime,
@@ -160,6 +172,13 @@ public int getCurrParallelIndexCapacityUsed()
     return currParallelIndexCapacityUsed;
   }
 
+  @JsonProperty("currCapacityUsedByTaskType")
+  @JsonInclude(JsonInclude.Include.NON_EMPTY)
+  public Map<String, Integer> getCurrCapacityUsedByTaskType()
+  {
+    return currCapacityUsedByTaskType;
+  }
+
   @JsonProperty("availabilityGroups")
   public Set<String> getAvailabilityGroups()
   {
@@ -243,6 +262,9 @@ public boolean equals(Object o)
     if (currParallelIndexCapacityUsed != that.currParallelIndexCapacityUsed) {
       return false;
     }
+    if (!currCapacityUsedByTaskType.equals(that.currCapacityUsedByTaskType)) {
+      return false;
+    }
     if (!worker.equals(that.worker)) {
       return false;
     }
@@ -266,6 +288,7 @@ public int hashCode()
     int result = worker.hashCode();
     result = 31 * result + currCapacityUsed;
     result = 31 * result + currParallelIndexCapacityUsed;
+    result = 31 * result + currCapacityUsedByTaskType.hashCode();
     result = 31 * result + availabilityGroups.hashCode();
     result = 31 * result + runningTasks.hashCode();
     result = 31 * result + lastCompletedTaskTime.hashCode();
@@ -280,6 +303,7 @@ public String toString()
            "worker=" + worker +
            ", currCapacityUsed=" + currCapacityUsed +
            ", currParallelIndexCapacityUsed=" + currParallelIndexCapacityUsed +
+           ", currCapacityUsedByTaskType=" + currCapacityUsedByTaskType +
            ", availabilityGroups=" + availabilityGroups +
            ", runningTasks=" + runningTasks +
            ", lastCompletedTaskTime=" + lastCompletedTaskTime +
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/autoscaling/PendingTaskBasedWorkerProvisioningStrategy.java b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/autoscaling/PendingTaskBasedWorkerProvisioningStrategy.java
index 0d715b53549f..101226788936 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/autoscaling/PendingTaskBasedWorkerProvisioningStrategy.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/autoscaling/PendingTaskBasedWorkerProvisioningStrategy.java
@@ -482,10 +482,16 @@ private static ImmutableWorkerInfo workerWithTask(ImmutableWorkerInfo immutableW
     int parallelIndexTaskCapacity = task.getType().equals(ParallelIndexSupervisorTask.TYPE)
                                     ? task.getTaskResource().getRequiredCapacity()
                                     : 0;
+    int taskCapacity = task.getTaskResource().getRequiredCapacity();
+
+    final Map<String, Integer> typeSpecificCapacity = new HashMap<>(immutableWorker.getCurrCapacityUsedByTaskType());
+    typeSpecificCapacity.merge(task.getType(), taskCapacity, Integer::sum);
+
     return new ImmutableWorkerInfo(
         immutableWorker.getWorker(),
         immutableWorker.getCurrCapacityUsed() + 1,
         immutableWorker.getCurrParallelIndexCapacityUsed() + parallelIndexTaskCapacity,
+        typeSpecificCapacity,
         Sets.union(
             immutableWorker.getAvailabilityGroups(),
             Sets.newHashSet(
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithAffinityWorkerSelectStrategy.java b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithAffinityWorkerSelectStrategy.java
index 6d28ae78fd04..e60aeae018a7 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithAffinityWorkerSelectStrategy.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithAffinityWorkerSelectStrategy.java
@@ -29,9 +29,10 @@ public class EqualDistributionWithAffinityWorkerSelectStrategy extends EqualDist
 {
   @JsonCreator
   public EqualDistributionWithAffinityWorkerSelectStrategy(
-      @JsonProperty("affinityConfig") AffinityConfig affinityConfig
+      @JsonProperty("affinityConfig") AffinityConfig affinityConfig,
+      @JsonProperty("taskLimits") TaskLimits taskLimits
   )
   {
-    super(affinityConfig);
+    super(affinityConfig, taskLimits);
   }
 }
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithCategorySpecWorkerSelectStrategy.java b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithCategorySpecWorkerSelectStrategy.java
index ec65693ac3dd..b3715aec2859 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithCategorySpecWorkerSelectStrategy.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithCategorySpecWorkerSelectStrategy.java
@@ -22,6 +22,7 @@
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.collect.ImmutableMap;
+import org.apache.druid.common.config.Configs;
 import org.apache.druid.indexing.common.task.Task;
 import org.apache.druid.indexing.overlord.ImmutableWorkerInfo;
 import org.apache.druid.indexing.overlord.config.WorkerTaskRunnerConfig;
@@ -32,13 +33,16 @@
 public class EqualDistributionWithCategorySpecWorkerSelectStrategy implements WorkerSelectStrategy
 {
   private final WorkerCategorySpec workerCategorySpec;
+  private final TaskLimits taskLimits;
 
   @JsonCreator
   public EqualDistributionWithCategorySpecWorkerSelectStrategy(
-      @JsonProperty("workerCategorySpec") WorkerCategorySpec workerCategorySpec
+      @JsonProperty("workerCategorySpec") WorkerCategorySpec workerCategorySpec,
+      @JsonProperty("taskLimits") @Nullable TaskLimits taskLimits
   )
   {
     this.workerCategorySpec = workerCategorySpec;
+    this.taskLimits = Configs.valueOrDefault(taskLimits, TaskLimits.EMPTY);
   }
 
   @JsonProperty
@@ -47,6 +51,12 @@ public WorkerCategorySpec getWorkerCategorySpec()
     return workerCategorySpec;
   }
 
+  @JsonProperty
+  public TaskLimits getTaskLimits()
+  {
+    return taskLimits;
+  }
+
   @Nullable
   @Override
   public ImmutableWorkerInfo findWorkerForTask(
@@ -60,7 +70,8 @@ public ImmutableWorkerInfo findWorkerForTask(
         zkWorkers,
         config,
         workerCategorySpec,
-        EqualDistributionWorkerSelectStrategy::selectFromEligibleWorkers
+        EqualDistributionWorkerSelectStrategy::selectFromEligibleWorkers,
+        taskLimits
     );
   }
 
@@ -74,13 +85,14 @@ public boolean equals(final Object o)
       return false;
     }
     final EqualDistributionWithCategorySpecWorkerSelectStrategy that = (EqualDistributionWithCategorySpecWorkerSelectStrategy) o;
-    return Objects.equals(workerCategorySpec, that.workerCategorySpec);
+    return Objects.equals(workerCategorySpec, that.workerCategorySpec)
+           && Objects.equals(taskLimits, that.taskLimits);
   }
 
   @Override
   public int hashCode()
   {
-    return Objects.hash(workerCategorySpec);
+    return Objects.hash(workerCategorySpec, taskLimits);
   }
 
   @Override
@@ -88,6 +100,7 @@ public String toString()
   {
     return "EqualDistributionWithCategorySpecWorkerSelectStrategy{" +
            "workerCategorySpec=" + workerCategorySpec +
+           ", taskLimits=" + taskLimits +
            '}';
   }
 }
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWorkerSelectStrategy.java b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWorkerSelectStrategy.java
index afb020e9f7ab..f3775d91e52c 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWorkerSelectStrategy.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWorkerSelectStrategy.java
@@ -22,10 +22,12 @@
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.collect.ImmutableMap;
+import org.apache.druid.common.config.Configs;
 import org.apache.druid.indexing.common.task.Task;
 import org.apache.druid.indexing.overlord.ImmutableWorkerInfo;
 import org.apache.druid.indexing.overlord.config.WorkerTaskRunnerConfig;
 
+import javax.annotation.Nullable;
 import java.util.Comparator;
 import java.util.Map;
 import java.util.Objects;
@@ -35,13 +37,16 @@
 public class EqualDistributionWorkerSelectStrategy implements WorkerSelectStrategy
 {
   private final AffinityConfig affinityConfig;
+  private final TaskLimits taskLimits;
 
   @JsonCreator
   public EqualDistributionWorkerSelectStrategy(
-      @JsonProperty("affinityConfig") AffinityConfig affinityConfig
+      @JsonProperty("affinityConfig") AffinityConfig affinityConfig,
+      @JsonProperty("taskLimits") @Nullable TaskLimits taskLimits
   )
   {
     this.affinityConfig = affinityConfig;
+    this.taskLimits = Configs.valueOrDefault(taskLimits, TaskLimits.EMPTY);
   }
 
   @JsonProperty
@@ -50,6 +55,12 @@ public AffinityConfig getAffinityConfig()
     return affinityConfig;
   }
 
+  @JsonProperty
+  public TaskLimits getTaskLimits()
+  {
+    return taskLimits;
+  }
+
   @Override
   public ImmutableWorkerInfo findWorkerForTask(
       final WorkerTaskRunnerConfig config,
@@ -62,7 +73,8 @@ public ImmutableWorkerInfo findWorkerForTask(
         zkWorkers,
         config,
         affinityConfig,
-        EqualDistributionWorkerSelectStrategy::selectFromEligibleWorkers
+        EqualDistributionWorkerSelectStrategy::selectFromEligibleWorkers,
+        taskLimits
     );
   }
 
@@ -83,13 +95,14 @@ public boolean equals(final Object o)
       return false;
     }
     final EqualDistributionWorkerSelectStrategy that = (EqualDistributionWorkerSelectStrategy) o;
-    return Objects.equals(affinityConfig, that.affinityConfig);
+    return Objects.equals(affinityConfig, that.affinityConfig)
+           && Objects.equals(taskLimits, that.taskLimits);
   }
 
   @Override
   public int hashCode()
   {
-    return Objects.hash(affinityConfig);
+    return Objects.hash(affinityConfig, taskLimits);
   }
 
   @Override
@@ -97,6 +110,7 @@ public String toString()
   {
     return "EqualDistributionWorkerSelectStrategy{" +
            "affinityConfig=" + affinityConfig +
+           ", taskLimits=" + taskLimits +
            '}';
   }
 }
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithAffinityWorkerSelectStrategy.java b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithAffinityWorkerSelectStrategy.java
index 46c303f90481..efa24b75b5f2 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithAffinityWorkerSelectStrategy.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithAffinityWorkerSelectStrategy.java
@@ -29,9 +29,10 @@ public class FillCapacityWithAffinityWorkerSelectStrategy extends FillCapacityWo
 {
   @JsonCreator
   public FillCapacityWithAffinityWorkerSelectStrategy(
-      @JsonProperty("affinityConfig") AffinityConfig affinityConfig
+      @JsonProperty("affinityConfig") AffinityConfig affinityConfig,
+      @JsonProperty("taskLimits") TaskLimits taskLimits
   )
   {
-    super(affinityConfig);
+    super(affinityConfig, taskLimits);
   }
 }
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithCategorySpecWorkerSelectStrategy.java b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithCategorySpecWorkerSelectStrategy.java
index 3dcdfe9a5401..d50b19824cf3 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithCategorySpecWorkerSelectStrategy.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithCategorySpecWorkerSelectStrategy.java
@@ -22,6 +22,7 @@
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.collect.ImmutableMap;
+import org.apache.druid.common.config.Configs;
 import org.apache.druid.indexing.common.task.Task;
 import org.apache.druid.indexing.overlord.ImmutableWorkerInfo;
 import org.apache.druid.indexing.overlord.config.WorkerTaskRunnerConfig;
@@ -32,13 +33,17 @@
 public class FillCapacityWithCategorySpecWorkerSelectStrategy implements WorkerSelectStrategy
 {
   private final WorkerCategorySpec workerCategorySpec;
+  private final TaskLimits taskLimits;
+
 
   @JsonCreator
   public FillCapacityWithCategorySpecWorkerSelectStrategy(
-      @JsonProperty("workerCategorySpec") WorkerCategorySpec workerCategorySpec
+      @JsonProperty("workerCategorySpec") WorkerCategorySpec workerCategorySpec,
+      @JsonProperty("taskLimits") @Nullable TaskLimits taskLimits
   )
   {
     this.workerCategorySpec = workerCategorySpec;
+    this.taskLimits = Configs.valueOrDefault(taskLimits, TaskLimits.EMPTY);
   }
 
   @JsonProperty
@@ -47,6 +52,12 @@ public WorkerCategorySpec getWorkerCategorySpec()
     return workerCategorySpec;
   }
 
+  @JsonProperty
+  public TaskLimits getTaskLimits()
+  {
+    return taskLimits;
+  }
+
   @Nullable
   @Override
   public ImmutableWorkerInfo findWorkerForTask(
@@ -60,7 +71,8 @@ public ImmutableWorkerInfo findWorkerForTask(
         zkWorkers,
         config,
         workerCategorySpec,
-        FillCapacityWorkerSelectStrategy::selectFromEligibleWorkers
+        FillCapacityWorkerSelectStrategy::selectFromEligibleWorkers,
+        taskLimits
     );
   }
 
@@ -74,13 +86,14 @@ public boolean equals(final Object o)
       return false;
     }
     final FillCapacityWithCategorySpecWorkerSelectStrategy that = (FillCapacityWithCategorySpecWorkerSelectStrategy) o;
-    return Objects.equals(workerCategorySpec, that.workerCategorySpec);
+    return Objects.equals(workerCategorySpec, that.workerCategorySpec)
+           && Objects.equals(taskLimits, that.taskLimits);
   }
 
   @Override
   public int hashCode()
   {
-    return Objects.hash(workerCategorySpec);
+    return Objects.hash(workerCategorySpec, taskLimits);
   }
 
   @Override
@@ -88,6 +101,7 @@ public String toString()
   {
     return "FillCapacityWithCategorySpecWorkerSelectStrategy{" +
            "workerCategorySpec=" + workerCategorySpec +
+           ", taskLimits=" + taskLimits +
            '}';
   }
 }
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/FillCapacityWorkerSelectStrategy.java b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/FillCapacityWorkerSelectStrategy.java
index 47ac65b8271d..bd8b53bacecd 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/FillCapacityWorkerSelectStrategy.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/FillCapacityWorkerSelectStrategy.java
@@ -22,10 +22,12 @@
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.collect.ImmutableMap;
+import org.apache.druid.common.config.Configs;
 import org.apache.druid.indexing.common.task.Task;
 import org.apache.druid.indexing.overlord.ImmutableWorkerInfo;
 import org.apache.druid.indexing.overlord.config.WorkerTaskRunnerConfig;
 
+import javax.annotation.Nullable;
 import java.util.Comparator;
 import java.util.Map;
 import java.util.Objects;
@@ -33,13 +35,16 @@
 public class FillCapacityWorkerSelectStrategy implements WorkerSelectStrategy
 {
   private final AffinityConfig affinityConfig;
+  private final TaskLimits taskLimits;
 
   @JsonCreator
   public FillCapacityWorkerSelectStrategy(
-      @JsonProperty("affinityConfig") AffinityConfig affinityConfig
+      @JsonProperty("affinityConfig") AffinityConfig affinityConfig,
+      @JsonProperty("taskLimits") @Nullable TaskLimits taskLimits
   )
   {
     this.affinityConfig = affinityConfig;
+    this.taskLimits = Configs.valueOrDefault(taskLimits, TaskLimits.EMPTY);
   }
 
   @JsonProperty
@@ -48,6 +53,12 @@ public AffinityConfig getAffinityConfig()
     return affinityConfig;
   }
 
+  @JsonProperty
+  public TaskLimits getTaskLimits()
+  {
+    return taskLimits;
+  }
+
   @Override
   public ImmutableWorkerInfo findWorkerForTask(
       final WorkerTaskRunnerConfig config,
@@ -60,7 +71,8 @@ public ImmutableWorkerInfo findWorkerForTask(
         zkWorkers,
         config,
         affinityConfig,
-        FillCapacityWorkerSelectStrategy::selectFromEligibleWorkers
+        FillCapacityWorkerSelectStrategy::selectFromEligibleWorkers,
+        taskLimits
     );
   }
 
@@ -81,13 +93,14 @@ public boolean equals(final Object o)
       return false;
     }
     final FillCapacityWorkerSelectStrategy that = (FillCapacityWorkerSelectStrategy) o;
-    return Objects.equals(affinityConfig, that.affinityConfig);
+    return Objects.equals(affinityConfig, that.affinityConfig)
+           && Objects.equals(taskLimits, that.taskLimits);
   }
 
   @Override
   public int hashCode()
   {
-    return Objects.hash(affinityConfig);
+    return Objects.hash(affinityConfig, taskLimits);
   }
 
   @Override
@@ -95,6 +108,7 @@ public String toString()
   {
     return "FillCapacityWorkerSelectStrategy{" +
            "affinityConfig=" + affinityConfig +
+           ", taskLimits=" + taskLimits +
            '}';
   }
 }
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/TaskLimits.java b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/TaskLimits.java
new file mode 100644
index 000000000000..39e6333c62f5
--- /dev/null
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/TaskLimits.java
@@ -0,0 +1,195 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.indexing.overlord.setup;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.apache.druid.common.config.Configs;
+import org.apache.druid.error.InvalidInput;
+import org.apache.druid.indexing.common.task.Task;
+
+import javax.annotation.Nullable;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Defines global limits for task execution using absolute slot counts and proportional ratios.
+ *
+ * <p>Task count limits ({@code maxSlotCountByType}) define the maximum number of slots per task type.
+ * Task ratios ({@code maxSlotRatioByType}) define the proportion of total slots a task type can use.
+ * If both are set for a task type, the lower limit applies.</p>
+ *
+ * <p>Example:
+ * {@code maxSlotCountByType = {"index_parallel": 3, "query_controller": 5}}
+ * {@code maxSlotRatioByType = {"index_parallel": 0.5, "query_controller": 0.25}}</p>
+ */
+public class TaskLimits
+{
+  public static final TaskLimits EMPTY = new TaskLimits();
+  private final Map<String, Integer> maxSlotCountByType;
+  private final Map<String, Double> maxSlotRatioByType;
+
+  private TaskLimits()
+  {
+    this(Map.of(), Map.of());
+  }
+
+  @JsonCreator
+  public TaskLimits(
+      @JsonProperty("maxSlotCountByType") @Nullable Map<String, Integer> maxSlotCountByType,
+      @JsonProperty("maxSlotRatioByType") @Nullable Map<String, Double> maxSlotRatioByType
+  )
+  {
+    validateLimits(maxSlotCountByType, maxSlotRatioByType);
+    this.maxSlotCountByType = Configs.valueOrDefault(maxSlotCountByType, Collections.emptyMap());
+    this.maxSlotRatioByType = Configs.valueOrDefault(maxSlotRatioByType, Collections.emptyMap());
+  }
+
+  /**
+   * Determines whether the given task can be executed based on task limits and available capacity.
+   *
+   * @param task             The task to check.
+   * @param currentSlotsUsed The current capacity used by tasks of the same type.
+   * @param totalCapacity    The total available capacity across all workers.
+   * @return {@code true} if the task meets the defined limits and capacity constraints; {@code false} otherwise.
+   */
+  public boolean canRunTask(Task task, Integer currentSlotsUsed, Integer totalCapacity)
+  {
+    if (maxSlotRatioByType.isEmpty() && maxSlotCountByType.isEmpty()) {
+      return true;
+    }
+    return meetsTaskLimit(
+        task,
+        currentSlotsUsed,
+        totalCapacity
+    );
+  }
+
+  private boolean meetsTaskLimit(
+      Task task,
+      Integer currentSlotsUsed,
+      Integer totalCapacity
+  )
+  {
+    final Integer limit = getLimitForTask(task.getType(), totalCapacity);
+
+    if (limit == null) {
+      return true; // No limit specified, so task can run
+    }
+
+    int requiredCapacity = task.getTaskResource().getRequiredCapacity();
+
+    return hasCapacityBasedOnLimit(limit, currentSlotsUsed, requiredCapacity);
+  }
+
+  private Integer getLimitForTask(
+      String taskType,
+      Integer totalCapacity
+  )
+  {
+    Integer absoluteLimit = maxSlotCountByType.get(taskType);
+    Double ratioLimit = maxSlotRatioByType.get(taskType);
+
+    if (absoluteLimit == null && ratioLimit == null) {
+      return null;
+    }
+
+    if (ratioLimit != null) {
+      int ratioBasedLimit = calculateTaskCapacityFromRatio(ratioLimit, totalCapacity);
+      if (absoluteLimit != null) {
+        return Math.min(absoluteLimit, ratioBasedLimit);
+      } else {
+        return ratioBasedLimit;
+      }
+    } else {
+      return absoluteLimit;
+    }
+  }
+
+  private boolean hasCapacityBasedOnLimit(int limit, int currentCapacityUsed, int requiredCapacity)
+  {
+    return limit - currentCapacityUsed >= requiredCapacity;
+  }
+
+  private int calculateTaskCapacityFromRatio(double taskSlotRatio, int totalCapacity)
+  {
+    int workerParallelIndexCapacity = (int) Math.floor(taskSlotRatio * totalCapacity);
+    return Math.max(1, Math.min(workerParallelIndexCapacity, totalCapacity));
+  }
+
+  private void validateLimits(Map<String, Integer> taskCountLimits, Map<String, Double> taskRatios)
+  {
+    if (taskCountLimits != null && taskCountLimits.values().stream().anyMatch(val -> val < 0)) {
+      throw InvalidInput.exception(
+          "Max task slot count limit for any type must be greater than zero. Found[%s].",
+          taskCountLimits
+      );
+    } else if (taskRatios != null && taskRatios.values().stream().anyMatch(val -> val < 0 || val > 1)) {
+      throw InvalidInput.exception(
+          "Max task slot ratios should be in the interval of [0, 1]. Found[%s].",
+          taskCountLimits
+      );
+    }
+  }
+
+  @JsonProperty
+  public Map<String, Integer> getMaxSlotCountByType()
+  {
+    return maxSlotCountByType;
+  }
+
+  @JsonProperty
+  public Map<String, Double> getMaxSlotRatioByType()
+  {
+    return maxSlotRatioByType;
+  }
+
+  @Override
+  public boolean equals(Object o)
+  {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    TaskLimits that = (TaskLimits) o;
+    return Objects.equals(maxSlotCountByType, that.maxSlotCountByType) && Objects.equals(
+        maxSlotRatioByType,
+        that.maxSlotRatioByType
+    );
+  }
+
+  @Override
+  public int hashCode()
+  {
+    return Objects.hash(maxSlotCountByType, maxSlotRatioByType);
+  }
+
+  @Override
+  public String toString()
+  {
+    return "TaskLimits{" +
+           "maxSlotCountByType=" + maxSlotCountByType +
+           ", maxSlotRatioByType=" + maxSlotRatioByType +
+           '}';
+  }
+}
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/WorkerBehaviorConfig.java b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/WorkerBehaviorConfig.java
index ffc30f55e648..4b867a4bb10b 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/WorkerBehaviorConfig.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/WorkerBehaviorConfig.java
@@ -40,7 +40,7 @@
 public interface WorkerBehaviorConfig
 {
   String CONFIG_KEY = "worker.config";
-  WorkerSelectStrategy DEFAULT_STRATEGY = new EqualDistributionWorkerSelectStrategy(null);
+  WorkerSelectStrategy DEFAULT_STRATEGY = new EqualDistributionWorkerSelectStrategy(null, null);
 
   WorkerSelectStrategy getSelectStrategy();
 }
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/WorkerSelectUtils.java b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/WorkerSelectUtils.java
index c3832daae32f..be4e8426008b 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/WorkerSelectUtils.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/setup/WorkerSelectUtils.java
@@ -26,6 +26,7 @@
 import org.apache.druid.indexing.overlord.config.WorkerTaskRunnerConfig;
 
 import javax.annotation.Nullable;
+import java.util.Collections;
 import java.util.Map;
 import java.util.Set;
 import java.util.function.Function;
@@ -54,10 +55,11 @@ public static ImmutableWorkerInfo selectWorker(
       final Map<String, ImmutableWorkerInfo> allWorkers,
       final WorkerTaskRunnerConfig workerTaskRunnerConfig,
       @Nullable final AffinityConfig affinityConfig,
-      final Function<ImmutableMap<String, ImmutableWorkerInfo>, ImmutableWorkerInfo> workerSelector
+      final Function<ImmutableMap<String, ImmutableWorkerInfo>, ImmutableWorkerInfo> workerSelector,
+      final TaskLimits taskLimits
   )
   {
-    final Map<String, ImmutableWorkerInfo> runnableWorkers = getRunnableWorkers(task, allWorkers, workerTaskRunnerConfig);
+    final Map<String, ImmutableWorkerInfo> runnableWorkers = getRunnableWorkers(task, allWorkers, workerTaskRunnerConfig, taskLimits);
 
     if (affinityConfig == null) {
       // All runnable workers are valid.
@@ -105,10 +107,11 @@ public static ImmutableWorkerInfo selectWorker(
       final Map<String, ImmutableWorkerInfo> allWorkers,
       final WorkerTaskRunnerConfig workerTaskRunnerConfig,
       @Nullable final WorkerCategorySpec workerCategorySpec,
-      final Function<ImmutableMap<String, ImmutableWorkerInfo>, ImmutableWorkerInfo> workerSelector
+      final Function<ImmutableMap<String, ImmutableWorkerInfo>, ImmutableWorkerInfo> workerSelector,
+      final TaskLimits taskLimits
   )
   {
-    final Map<String, ImmutableWorkerInfo> runnableWorkers = getRunnableWorkers(task, allWorkers, workerTaskRunnerConfig);
+    final Map<String, ImmutableWorkerInfo> runnableWorkers = getRunnableWorkers(task, allWorkers, workerTaskRunnerConfig, taskLimits);
 
     // select worker according to worker category spec
     if (workerCategorySpec != null) {
@@ -145,9 +148,17 @@ public static ImmutableWorkerInfo selectWorker(
   private static Map<String, ImmutableWorkerInfo> getRunnableWorkers(
       final Task task,
       final Map<String, ImmutableWorkerInfo> allWorkers,
-      final WorkerTaskRunnerConfig workerTaskRunnerConfig
+      final WorkerTaskRunnerConfig workerTaskRunnerConfig,
+      final TaskLimits taskLimits
   )
   {
+    if (!taskLimits.canRunTask(
+        task,
+        getTotalCapacityUsedByType(allWorkers, task.getType()),
+        getTotalCapacity(allWorkers)
+    )) {
+      return Collections.emptyMap();
+    }
     return allWorkers.values()
                      .stream()
                      .filter(worker -> worker.canRunTask(task, workerTaskRunnerConfig.getParallelIndexTaskSlotRatio())
@@ -193,4 +204,20 @@ private static ImmutableMap<String, ImmutableWorkerInfo> getNonAffinityWorkers(
         )
     );
   }
+
+  private static int getTotalCapacity(final Map<String, ImmutableWorkerInfo> allWorkers)
+  {
+    return allWorkers.values().stream().mapToInt(workerInfo -> workerInfo.getWorker().getCapacity()).sum();
+  }
+
+  private static int getTotalCapacityUsedByType(
+      final Map<String, ImmutableWorkerInfo> allWorkers,
+      final String taskType
+  )
+  {
+    return allWorkers.values()
+                     .stream()
+                     .mapToInt(workerInfo -> workerInfo.getCurrCapacityUsedByTaskType().getOrDefault(taskType, 0))
+                     .sum();
+  }
 }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/ImmutableWorkerInfoTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/ImmutableWorkerInfoTest.java
index e373eb982a36..122e9892dc89 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/ImmutableWorkerInfoTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/ImmutableWorkerInfoTest.java
@@ -33,6 +33,8 @@
 import org.junit.Assert;
 import org.junit.Test;
 
+import java.util.Collections;
+
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -201,6 +203,7 @@ public void testEqualsAndSerde()
         ),
         3,
         0,
+        Collections.emptyMap(),
         ImmutableSet.of("grp1", "grp2"),
         ImmutableSet.of("task1", "task2"),
         DateTimes.of("2015-01-01T01:01:01Z"),
@@ -211,6 +214,7 @@ public void testEqualsAndSerde()
         ),
         2,
         0,
+        Collections.emptyMap(),
         ImmutableSet.of("grp1", "grp2"),
         ImmutableSet.of("task1", "task2"),
         DateTimes.of("2015-01-01T01:01:02Z"),
@@ -225,6 +229,7 @@ public void test_canRunTask()
         new Worker("http", "testWorker2", "192.0.0.1", 10, "v1", WorkerConfig.DEFAULT_CATEGORY),
         6,
         0,
+        Collections.emptyMap(),
         ImmutableSet.of("grp1", "grp2"),
         ImmutableSet.of("task1", "task2"),
         DateTimes.of("2015-01-01T01:01:02Z")
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/RemoteTaskRunnerTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/RemoteTaskRunnerTest.java
index 8207584f2136..7bbd6ef5e37e 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/RemoteTaskRunnerTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/RemoteTaskRunnerTest.java
@@ -632,7 +632,7 @@ public void testGetMaximumCapacity_noAutoScaler()
         new TestRemoteTaskRunnerConfig(TIMEOUT_PERIOD),
         new TestProvisioningStrategy<>(),
         httpClient,
-        new DefaultWorkerBehaviorConfig(new EqualDistributionWorkerSelectStrategy(null), null)
+        new DefaultWorkerBehaviorConfig(new EqualDistributionWorkerSelectStrategy(null, null), null)
     );
     Assert.assertEquals(-1, remoteTaskRunner.getMaximumCapacityWithAutoscale());
   }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/autoscaling/PendingTaskBasedProvisioningStrategyTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/autoscaling/PendingTaskBasedProvisioningStrategyTest.java
index 8a1232b95714..eaba6f9e6f9a 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/autoscaling/PendingTaskBasedProvisioningStrategyTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/autoscaling/PendingTaskBasedProvisioningStrategyTest.java
@@ -92,7 +92,7 @@ public void setUp()
 
     workerConfig = new AtomicReference<>(
         new DefaultWorkerBehaviorConfig(
-            new FillCapacityWorkerSelectStrategy(null),
+            new FillCapacityWorkerSelectStrategy(null, null),
             autoScaler
         )
     );
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/hrtr/HttpRemoteTaskRunnerTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/hrtr/HttpRemoteTaskRunnerTest.java
index 91b0778c9505..3e5c862d7a63 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/hrtr/HttpRemoteTaskRunnerTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/hrtr/HttpRemoteTaskRunnerTest.java
@@ -1818,7 +1818,7 @@ public void testGetMaximumCapacity_noAutoScaler()
         TestHelper.makeJsonMapper(),
         new HttpRemoteTaskRunnerConfig(),
         EasyMock.createNiceMock(HttpClient.class),
-        DSuppliers.of(new AtomicReference<>(new DefaultWorkerBehaviorConfig(new EqualDistributionWorkerSelectStrategy(null), null))),
+        DSuppliers.of(new AtomicReference<>(new DefaultWorkerBehaviorConfig(new EqualDistributionWorkerSelectStrategy(null, null), null))),
         new TestProvisioningStrategy<>(),
         druidNodeDiscoveryProvider,
         EasyMock.createMock(TaskStorage.class),
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithAffinityWorkerSelectStrategyTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithAffinityWorkerSelectStrategyTest.java
index 0641d3a8d919..1e81be9cc978 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithAffinityWorkerSelectStrategyTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithAffinityWorkerSelectStrategyTest.java
@@ -32,7 +32,10 @@
 import org.junit.Assert;
 import org.junit.Test;
 
+import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
 
 public class EqualDistributionWithAffinityWorkerSelectStrategyTest
 {
@@ -40,7 +43,8 @@ public class EqualDistributionWithAffinityWorkerSelectStrategyTest
   public void testFindWorkerForTask()
   {
     EqualDistributionWorkerSelectStrategy strategy = new EqualDistributionWithAffinityWorkerSelectStrategy(
-        new AffinityConfig(ImmutableMap.of("foo", ImmutableSet.of("localhost1", "localhost2", "localhost3")), false)
+        new AffinityConfig(ImmutableMap.of("foo", ImmutableSet.of("localhost1", "localhost2", "localhost3")), false),
+        null
     );
 
     NoopTask noopTask = NoopTask.forDatasource("foo");
@@ -85,7 +89,8 @@ public void testFindWorkerForTask()
   public void testFindWorkerForTaskWithNulls()
   {
     EqualDistributionWorkerSelectStrategy strategy = new EqualDistributionWithAffinityWorkerSelectStrategy(
-            new AffinityConfig(ImmutableMap.of("foo", ImmutableSet.of("localhost")), false)
+            new AffinityConfig(ImmutableMap.of("foo", ImmutableSet.of("localhost")), false),
+            null
     );
 
     ImmutableWorkerInfo worker = strategy.findWorkerForTask(
@@ -115,7 +120,8 @@ public void testFindWorkerForTaskWithNulls()
   public void testIsolation()
   {
     EqualDistributionWorkerSelectStrategy strategy = new EqualDistributionWithAffinityWorkerSelectStrategy(
-            new AffinityConfig(ImmutableMap.of("foo", ImmutableSet.of("localhost")), false)
+            new AffinityConfig(ImmutableMap.of("foo", ImmutableSet.of("localhost")), false),
+            null
     );
 
     ImmutableWorkerInfo worker = strategy.findWorkerForTask(
@@ -139,7 +145,8 @@ public void testSerde() throws Exception
   {
     final ObjectMapper objectMapper = TestHelper.makeJsonMapper();
     final EqualDistributionWorkerSelectStrategy strategy = new EqualDistributionWithAffinityWorkerSelectStrategy(
-        new AffinityConfig(ImmutableMap.of("foo", ImmutableSet.of("localhost")), false)
+        new AffinityConfig(ImmutableMap.of("foo", ImmutableSet.of("localhost")), false),
+        null
     );
     final WorkerSelectStrategy strategy2 = objectMapper.readValue(
         objectMapper.writeValueAsBytes(strategy),
@@ -147,4 +154,138 @@ public void testSerde() throws Exception
     );
     Assert.assertEquals(strategy, strategy2);
   }
+
+  @Test
+  public void testFindWorkerForTaskWithGlobalLimits()
+  {
+    Map<String, Integer> taskLimits = new HashMap<>();
+    taskLimits.put("noop", 2);
+
+    Map<String, Integer> capacityUsed = new HashMap<>();
+    capacityUsed.put("noop", 1);
+    EqualDistributionWorkerSelectStrategy strategy = new EqualDistributionWithAffinityWorkerSelectStrategy(
+        null,
+        new TaskLimits(taskLimits, null)
+    );
+
+    NoopTask noopTask = NoopTask.forDatasource("foo");
+    ImmutableWorkerInfo worker = strategy.findWorkerForTask(
+        new RemoteTaskRunnerConfig(),
+        ImmutableMap.of(
+            "localhost0",
+            new ImmutableWorkerInfo(
+                new Worker("http", "localhost0", "localhost0", 2, "v1", WorkerConfig.DEFAULT_CATEGORY), 0,
+                Set.of(),
+                Set.of(),
+                DateTimes.nowUtc()
+            ),
+            "localhost1",
+            new ImmutableWorkerInfo(
+                new Worker("http", "localhost1", "localhost1", 2, "v1", WorkerConfig.DEFAULT_CATEGORY), 0,
+                0,
+                capacityUsed,
+                Set.of(),
+                Set.of(),
+                DateTimes.nowUtc()
+            )
+        ),
+        noopTask
+    );
+    Assert.assertNotNull(worker);
+
+    ImmutableWorkerInfo worker1 = strategy.findWorkerForTask(
+        new RemoteTaskRunnerConfig(),
+        ImmutableMap.of(
+            "localhost0",
+            new ImmutableWorkerInfo(
+                new Worker("http", "localhost0", "localhost0", 2, "v1", WorkerConfig.DEFAULT_CATEGORY), 0,
+                0,
+                capacityUsed,
+                Set.of(),
+                Set.of(),
+                DateTimes.nowUtc()
+            ),
+            "localhost1",
+            new ImmutableWorkerInfo(
+                new Worker("http", "localhost1", "localhost1", 2, "v1", WorkerConfig.DEFAULT_CATEGORY), 0,
+                0,
+                capacityUsed,
+                Set.of(),
+                Set.of(),
+                DateTimes.nowUtc()
+            )
+        ),
+        noopTask
+    );
+
+    Assert.assertNull(worker1);
+
+  }
+
+  @Test
+  public void testFindWorkerForTaskWithGlobalRatios()
+  {
+    Map<String, Double> taskRatios = new HashMap<>();
+    taskRatios.put("noop", 0.5);
+
+    Map<String, Integer> capacityUsed = new HashMap<>();
+    capacityUsed.put("noop", 1);
+    EqualDistributionWorkerSelectStrategy strategy = new EqualDistributionWithAffinityWorkerSelectStrategy(
+        null,
+        new TaskLimits(null, taskRatios)
+    );
+
+    NoopTask noopTask = NoopTask.forDatasource("foo");
+    ImmutableWorkerInfo worker = strategy.findWorkerForTask(
+        new RemoteTaskRunnerConfig(),
+        ImmutableMap.of(
+            "localhost0",
+            new ImmutableWorkerInfo(
+                new Worker("http", "localhost0", "localhost0", 2, "v1", WorkerConfig.DEFAULT_CATEGORY), 0,
+                Set.of(),
+                Set.of(),
+                DateTimes.nowUtc()
+            ),
+            "localhost1",
+            new ImmutableWorkerInfo(
+                new Worker("http", "localhost1", "localhost1", 2, "v1", WorkerConfig.DEFAULT_CATEGORY), 0,
+                0,
+                capacityUsed,
+                Set.of(),
+                Set.of(),
+                DateTimes.nowUtc()
+            )
+        ),
+        noopTask
+    );
+    Assert.assertNotNull(worker);
+
+    ImmutableWorkerInfo worker1 = strategy.findWorkerForTask(
+        new RemoteTaskRunnerConfig(),
+        ImmutableMap.of(
+            "localhost0",
+            new ImmutableWorkerInfo(
+                new Worker("http", "localhost0", "localhost0", 2, "v1", WorkerConfig.DEFAULT_CATEGORY), 0,
+                0,
+                capacityUsed,
+                Set.of(),
+                Set.of(),
+                DateTimes.nowUtc()
+            ),
+            "localhost1",
+            new ImmutableWorkerInfo(
+                new Worker("http", "localhost1", "localhost1", 2, "v1", WorkerConfig.DEFAULT_CATEGORY), 0,
+                0,
+                capacityUsed,
+                Set.of(),
+                Set.of(),
+                DateTimes.nowUtc()
+            )
+        ),
+        noopTask
+    );
+
+    Assert.assertNull(worker1);
+
+  }
 }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithCategorySpecWorkerSelectStrategyTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithCategorySpecWorkerSelectStrategyTest.java
index 99a690a738df..6ac04a8920fc 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithCategorySpecWorkerSelectStrategyTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithCategorySpecWorkerSelectStrategyTest.java
@@ -176,8 +176,8 @@ public void testStrongTierSpec()
 
   private ImmutableWorkerInfo selectWorker(WorkerCategorySpec workerCategorySpec)
   {
-    final EqualDistributionWithCategorySpecWorkerSelectStrategy strategy = new EqualDistributionWithCategorySpecWorkerSelectStrategy(
-        workerCategorySpec);
+    final EqualDistributionWithCategorySpecWorkerSelectStrategy strategy =
+        new EqualDistributionWithCategorySpecWorkerSelectStrategy(workerCategorySpec, null);
 
     ImmutableWorkerInfo worker = strategy.findWorkerForTask(
         new RemoteTaskRunnerConfig(),
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWorkerSelectStrategyTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWorkerSelectStrategyTest.java
index dac25a3c9e34..582806416457 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWorkerSelectStrategyTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWorkerSelectStrategyTest.java
@@ -69,7 +69,7 @@ public class EqualDistributionWorkerSelectStrategyTest
   @Test
   public void testFindWorkerForTask()
   {
-    final EqualDistributionWorkerSelectStrategy strategy = new EqualDistributionWorkerSelectStrategy(null);
+    final EqualDistributionWorkerSelectStrategy strategy = new EqualDistributionWorkerSelectStrategy(null, null);
 
     ImmutableWorkerInfo worker = strategy.findWorkerForTask(
         new RemoteTaskRunnerConfig(),
@@ -97,7 +97,7 @@ public void testFindWorkerForTask()
   @Test
   public void testFindWorkerForTaskWhenSameCurrCapacityUsed()
   {
-    final EqualDistributionWorkerSelectStrategy strategy = new EqualDistributionWorkerSelectStrategy(null);
+    final EqualDistributionWorkerSelectStrategy strategy = new EqualDistributionWorkerSelectStrategy(null, null);
 
     ImmutableWorkerInfo worker = strategy.findWorkerForTask(
         new RemoteTaskRunnerConfig(),
@@ -126,7 +126,7 @@ public void testFindWorkerForTaskWhenSameCurrCapacityUsed()
   public void testOneDisableWorkerDifferentUsedCapacity()
   {
     String disabledVersion = "";
-    final EqualDistributionWorkerSelectStrategy strategy = new EqualDistributionWorkerSelectStrategy(null);
+    final EqualDistributionWorkerSelectStrategy strategy = new EqualDistributionWorkerSelectStrategy(null, null);
 
     ImmutableWorkerInfo worker = strategy.findWorkerForTask(
         new RemoteTaskRunnerConfig(),
@@ -155,7 +155,7 @@ public void testOneDisableWorkerDifferentUsedCapacity()
   public void testOneDisableWorkerSameUsedCapacity()
   {
     String disabledVersion = "";
-    final EqualDistributionWorkerSelectStrategy strategy = new EqualDistributionWorkerSelectStrategy(null);
+    final EqualDistributionWorkerSelectStrategy strategy = new EqualDistributionWorkerSelectStrategy(null, null);
 
     ImmutableWorkerInfo worker = strategy.findWorkerForTask(
         new RemoteTaskRunnerConfig(),
@@ -190,7 +190,8 @@ public void testWeakAffinity()
                 "bar", ImmutableSet.of("nonexistent-worker")
             ),
             false
-        )
+        ),
+        null
     );
 
     ImmutableWorkerInfo workerFoo = strategy.findWorkerForTask(
@@ -226,7 +227,8 @@ public void testStrongAffinity()
                 "bar", ImmutableSet.of("nonexistent-worker")
             ),
             true
-        )
+        ),
+        null
     );
 
     ImmutableWorkerInfo workerFoo = strategy.findWorkerForTask(
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithAffinityWorkerSelectStrategyTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithAffinityWorkerSelectStrategyTest.java
index 93f6c39b0f0c..207c6e43dda3 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithAffinityWorkerSelectStrategyTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithAffinityWorkerSelectStrategyTest.java
@@ -30,7 +30,9 @@
 import org.junit.Assert;
 import org.junit.Test;
 
+import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Map;
 
 public class FillCapacityWithAffinityWorkerSelectStrategyTest
 {
@@ -38,7 +40,8 @@ public class FillCapacityWithAffinityWorkerSelectStrategyTest
   public void testFindWorkerForTask()
   {
     FillCapacityWorkerSelectStrategy strategy = new FillCapacityWithAffinityWorkerSelectStrategy(
-        new AffinityConfig(ImmutableMap.of("foo", ImmutableSet.of("localhost")), false)
+        new AffinityConfig(ImmutableMap.of("foo", ImmutableSet.of("localhost")), false),
+        null
     );
 
     ImmutableWorkerInfo worker = strategy.findWorkerForTask(
@@ -68,7 +71,8 @@ public void testFindWorkerForTask()
   public void testFindWorkerForTaskWithNulls()
   {
     FillCapacityWorkerSelectStrategy strategy = new FillCapacityWithAffinityWorkerSelectStrategy(
-        new AffinityConfig(ImmutableMap.of("foo", ImmutableSet.of("localhost")), false)
+        new AffinityConfig(ImmutableMap.of("foo", ImmutableSet.of("localhost")), false),
+        null
     );
 
     ImmutableWorkerInfo worker = strategy.findWorkerForTask(
@@ -98,7 +102,8 @@ public void testFindWorkerForTaskWithNulls()
   public void testIsolation()
   {
     FillCapacityWorkerSelectStrategy strategy = new FillCapacityWithAffinityWorkerSelectStrategy(
-        new AffinityConfig(ImmutableMap.of("foo", ImmutableSet.of("localhost")), false)
+        new AffinityConfig(ImmutableMap.of("foo", ImmutableSet.of("localhost")), false),
+        null
     );
 
     ImmutableWorkerInfo worker = strategy.findWorkerForTask(
@@ -116,4 +121,138 @@ public void testIsolation()
     );
     Assert.assertNull(worker);
   }
+
+  @Test
+  public void testFindWorkerForTaskWithGlobalLimits()
+  {
+    Map<String, Integer> taskLimits = new HashMap<>();
+    taskLimits.put("noop", 2);
+
+    Map<String, Integer> capacityUsed = new HashMap<>();
+    capacityUsed.put("noop", 1);
+    FillCapacityWorkerSelectStrategy strategy = new FillCapacityWorkerSelectStrategy(
+        null,
+        new TaskLimits(taskLimits, null)
+    );
+
+    NoopTask noopTask = NoopTask.forDatasource("foo");
+    ImmutableWorkerInfo worker = strategy.findWorkerForTask(
+        new RemoteTaskRunnerConfig(),
+        ImmutableMap.of(
+            "localhost0",
+            new ImmutableWorkerInfo(
+                new Worker("http", "localhost0", "localhost0", 2, "v1", WorkerConfig.DEFAULT_CATEGORY), 0,
+                new HashSet<>(),
+                new HashSet<>(),
+                DateTimes.nowUtc()
+            ),
+            "localhost1",
+            new ImmutableWorkerInfo(
+                new Worker("http", "localhost1", "localhost1", 2, "v1", WorkerConfig.DEFAULT_CATEGORY), 0,
+                0,
+                capacityUsed,
+                new HashSet<>(),
+                new HashSet<>(),
+                DateTimes.nowUtc()
+            )
+        ),
+        noopTask
+    );
+    Assert.assertNotNull(worker);
+
+    ImmutableWorkerInfo worker1 = strategy.findWorkerForTask(
+        new RemoteTaskRunnerConfig(),
+        ImmutableMap.of(
+            "localhost0",
+            new ImmutableWorkerInfo(
+                new Worker("http", "localhost0", "localhost0", 2, "v1", WorkerConfig.DEFAULT_CATEGORY), 0,
+                0,
+                capacityUsed,
+                new HashSet<>(),
+                new HashSet<>(),
+                DateTimes.nowUtc()
+            ),
+            "localhost1",
+            new ImmutableWorkerInfo(
+                new Worker("http", "localhost1", "localhost1", 2, "v1", WorkerConfig.DEFAULT_CATEGORY), 0,
+                0,
+                capacityUsed,
+                new HashSet<>(),
+                new HashSet<>(),
+                DateTimes.nowUtc()
+            )
+        ),
+        noopTask
+    );
+
+    Assert.assertNull(worker1);
+
+  }
+
+  @Test
+  public void testFindWorkerForTaskWithGlobalRatios()
+  {
+    Map<String, Double> taskRatios = new HashMap<>();
+    taskRatios.put("noop", 0.5);
+
+    Map<String, Integer> capacityUsed = new HashMap<>();
+    capacityUsed.put("noop", 1);
+    FillCapacityWorkerSelectStrategy strategy = new FillCapacityWorkerSelectStrategy(
+        null,
+        new TaskLimits(null, taskRatios)
+    );
+
+    NoopTask noopTask = NoopTask.forDatasource("foo");
+    ImmutableWorkerInfo worker = strategy.findWorkerForTask(
+        new RemoteTaskRunnerConfig(),
+        ImmutableMap.of(
+            "localhost0",
+            new ImmutableWorkerInfo(
+                new Worker("http", "localhost0", "localhost0", 2, "v1", WorkerConfig.DEFAULT_CATEGORY), 0,
+                new HashSet<>(),
+                new HashSet<>(),
+                DateTimes.nowUtc()
+            ),
+            "localhost1",
+            new ImmutableWorkerInfo(
+                new Worker("http", "localhost1", "localhost1", 2, "v1", WorkerConfig.DEFAULT_CATEGORY), 0,
+                0,
+                capacityUsed,
+                new HashSet<>(),
+                new HashSet<>(),
+                DateTimes.nowUtc()
+            )
+        ),
+        noopTask
+    );
+    Assert.assertNotNull(worker);
+
+    ImmutableWorkerInfo worker1 = strategy.findWorkerForTask(
+        new RemoteTaskRunnerConfig(),
+        ImmutableMap.of(
+            "localhost0",
+            new ImmutableWorkerInfo(
+                new Worker("http", "localhost0", "localhost0", 2, "v1", WorkerConfig.DEFAULT_CATEGORY), 0,
+                0,
+                capacityUsed,
+                new HashSet<>(),
+                new HashSet<>(),
+                DateTimes.nowUtc()
+            ),
+            "localhost1",
+            new ImmutableWorkerInfo(
+                new Worker("http", "localhost1", "localhost1", 2, "v1", WorkerConfig.DEFAULT_CATEGORY), 0,
+                0,
+                capacityUsed,
+                new HashSet<>(),
+                new HashSet<>(),
+                DateTimes.nowUtc()
+            )
+        ),
+        noopTask
+    );
+
+    Assert.assertNull(worker1);
+
+  }
 }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithCategorySpecWorkerSelectStrategyTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithCategorySpecWorkerSelectStrategyTest.java
index bb4795d029e1..880ef743dca6 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithCategorySpecWorkerSelectStrategyTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithCategorySpecWorkerSelectStrategyTest.java
@@ -176,8 +176,8 @@ public void testStrongTierSpec()
 
   private ImmutableWorkerInfo selectWorker(WorkerCategorySpec workerCategorySpec)
   {
-    final FillCapacityWithCategorySpecWorkerSelectStrategy strategy = new FillCapacityWithCategorySpecWorkerSelectStrategy(
-        workerCategorySpec);
+    final FillCapacityWithCategorySpecWorkerSelectStrategy strategy =
+        new FillCapacityWithCategorySpecWorkerSelectStrategy(workerCategorySpec, null);
 
     ImmutableWorkerInfo worker = strategy.findWorkerForTask(
         new RemoteTaskRunnerConfig(),

From 06ad7b1f8542beee5fcf89006d590eef61463072 Mon Sep 17 00:00:00 2001
From: Clint Wylie <cwylie@apache.org>
Date: Thu, 6 Mar 2025 20:26:33 -0800
Subject: [PATCH 25/99] remove NullValueHandlingConfig, NullHandlingModule,
 NullHandling (#17778)

---
 codestyle/checkstyle.xml                      | 10 ---
 .../apache/druid/indexer/InputRowSerde.java   | 14 ++--
 .../druid/indexer/InputRowSerdeTest.java      |  8 +-
 .../druid/common/config/NullHandling.java     | 40 ----------
 .../config/NullValueHandlingConfig.java       | 74 -------------------
 .../druid/frame/field/StringFieldWriter.java  |  2 +-
 .../druid/guice/NullHandlingModule.java       | 37 ----------
 .../druid/guice/StartupInjectorBuilder.java   | 14 ++--
 .../druid/math/expr/ExpressionProcessing.java |  2 +-
 ...PairLongObjectDeltaEncodedStagedSerde.java |  6 +-
 ...izablePairLongObjectSimpleStagedSerde.java |  6 +-
 .../NullableNumericBufferAggregator.java      | 18 ++---
 .../NullableNumericVectorAggregator.java      | 12 +--
 ...PairLongDoubleDeltaEncodedStagedSerde.java |  4 +-
 ...izablePairLongDoubleSimpleStagedSerde.java |  4 +-
 ...ePairLongFloatDeltaEncodedStagedSerde.java |  4 +-
 ...lizablePairLongFloatSimpleStagedSerde.java |  4 +-
 ...lePairLongLongDeltaEncodedStagedSerde.java |  4 +-
 ...alizablePairLongLongSimpleStagedSerde.java |  4 +-
 .../SingleValueBufferAggregator.java          |  3 +-
 .../any/NumericAnyBufferAggregator.java       | 10 +--
 .../any/NumericAnyVectorAggregator.java       | 10 +--
 .../DoubleFirstLastVectorAggregator.java      | 12 +--
 .../FloatFirstLastVectorAggregator.java       | 12 +--
 .../LongFirstLastVectorAggregator.java        | 12 +--
 ...ingFirstLastDimensionVectorAggregator.java | 10 +--
 .../first/NumericFirstBufferAggregator.java   | 12 +--
 .../last/NumericLastBufferAggregator.java     | 12 +--
 .../druid/query/filter/SelectorDimFilter.java |  4 +-
 .../GrouperBufferComparatorUtils.java         |  6 +-
 .../epinephelinae/RowBasedGrouperHelper.java  |  8 +-
 ...ableDoubleGroupByVectorColumnSelector.java |  8 +-
 ...lableFloatGroupByVectorColumnSelector.java |  8 +-
 ...llableLongGroupByVectorColumnSelector.java |  8 +-
 .../segment/column/NullableTypeStrategy.java  | 13 ++--
 .../druid/segment/column/TypeSignature.java   |  4 +-
 .../druid/segment/column/TypeStrategies.java  | 26 ++++---
 .../druid/segment/column/TypeStrategy.java    |  5 +-
 .../druid/segment/data/FixedIndexed.java      |  4 +-
 .../segment/data/FixedIndexedWriter.java      |  4 +-
 .../druid/segment/data/FrontCodedIndexed.java |  4 +-
 .../segment/data/FrontCodedIndexedWriter.java |  4 +-
 .../data/FrontCodedIntArrayIndexed.java       |  4 +-
 .../data/FrontCodedIntArrayIndexedWriter.java |  4 +-
 .../guice/StartupInjectorBuilderTest.java     |  5 +-
 .../any/NumericAnyVectorAggregatorTest.java   | 18 ++---
 .../sql/calcite/BaseCalciteQueryTest.java     |  4 -
 47 files changed, 168 insertions(+), 333 deletions(-)
 delete mode 100644 processing/src/main/java/org/apache/druid/common/config/NullHandling.java
 delete mode 100644 processing/src/main/java/org/apache/druid/common/config/NullValueHandlingConfig.java
 delete mode 100644 processing/src/main/java/org/apache/druid/guice/NullHandlingModule.java

diff --git a/codestyle/checkstyle.xml b/codestyle/checkstyle.xml
index da70ddfad3ae..092150acbce9 100644
--- a/codestyle/checkstyle.xml
+++ b/codestyle/checkstyle.xml
@@ -196,16 +196,6 @@
       <property name="illegalPattern" value="true"/>
       <property name="message" value='Use toArray(new Object[0]) instead'/>
     </module>
-    <module name="Regexp">
-      <property name="format" value="Strings.emptyToNull"/>
-      <property name="illegalPattern" value="true"/>
-      <property name="message" value="Use org.apache.druid.common.config.NullHandling.emptyToNullIfNeeded instead"/>
-    </module>
-    <module name="Regexp">
-      <property name="format" value="Strings.nullToEmpty"/>
-      <property name="illegalPattern" value="true"/>
-      <property name="message" value="Use org.apache.druid.common.config.NullHandling.nullToEmptyIfNeeded instead"/>
-    </module>
 
     <module name="Regexp">
       <property name="format" value='@Produces\(\"text/plain\"\)'/>
diff --git a/indexing-hadoop/src/main/java/org/apache/druid/indexer/InputRowSerde.java b/indexing-hadoop/src/main/java/org/apache/druid/indexer/InputRowSerde.java
index 720fcafc4f9d..2c82dbfe1d6e 100644
--- a/indexing-hadoop/src/main/java/org/apache/druid/indexer/InputRowSerde.java
+++ b/indexing-hadoop/src/main/java/org/apache/druid/indexer/InputRowSerde.java
@@ -23,7 +23,6 @@
 import com.google.common.io.ByteArrayDataInput;
 import com.google.common.io.ByteArrayDataOutput;
 import com.google.common.io.ByteStreams;
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.data.input.InputRow;
 import org.apache.druid.data.input.MapBasedInputRow;
 import org.apache.druid.data.input.Rows;
@@ -38,6 +37,7 @@
 import org.apache.druid.segment.DimensionHandlerUtils;
 import org.apache.druid.segment.VirtualColumns;
 import org.apache.druid.segment.column.ColumnType;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.apache.druid.segment.column.ValueType;
 import org.apache.druid.segment.incremental.IncrementalIndex;
 import org.apache.druid.segment.serde.ComplexMetricSerde;
@@ -70,18 +70,18 @@ private static <T extends Number> void writeNullableNumeric(
       final Consumer<T> write)
   {
     if (ret == null) {
-      out.writeByte(NullHandling.IS_NULL_BYTE);
+      out.writeByte(TypeStrategies.IS_NULL_BYTE);
       return;
     }
 
-    out.writeByte(NullHandling.IS_NOT_NULL_BYTE);
+    out.writeByte(TypeStrategies.IS_NOT_NULL_BYTE);
 
     write.accept(ret);
   }
 
   private static boolean isNullByteSet(final ByteArrayDataInput in)
   {
-    return in.readByte() == NullHandling.IS_NULL_BYTE;
+    return in.readByte() == TypeStrategies.IS_NULL_BYTE;
   }
 
   public interface IndexSerdeTypeHelper<T>
@@ -336,9 +336,9 @@ public static SerializeResult toBytes(
           final ColumnType type = aggFactory.getIntermediateType();
 
           if (agg.isNull()) {
-            out.writeByte(NullHandling.IS_NULL_BYTE);
+            out.writeByte(TypeStrategies.IS_NULL_BYTE);
           } else {
-            out.writeByte(NullHandling.IS_NOT_NULL_BYTE);
+            out.writeByte(TypeStrategies.IS_NOT_NULL_BYTE);
             if (type.is(ValueType.FLOAT)) {
               out.writeFloat(agg.getFloat());
             } else if (type.is(ValueType.LONG)) {
@@ -467,7 +467,7 @@ public static InputRow fromBytes(
         final ColumnType type = agg.getIntermediateType();
         final byte metricNullability = in.readByte();
 
-        if (metricNullability == NullHandling.IS_NULL_BYTE) {
+        if (metricNullability == TypeStrategies.IS_NULL_BYTE) {
           // metric value is null.
           continue;
         }
diff --git a/indexing-hadoop/src/test/java/org/apache/druid/indexer/InputRowSerdeTest.java b/indexing-hadoop/src/test/java/org/apache/druid/indexer/InputRowSerdeTest.java
index 27a7a173f3be..36440fa87c10 100644
--- a/indexing-hadoop/src/test/java/org/apache/druid/indexer/InputRowSerdeTest.java
+++ b/indexing-hadoop/src/test/java/org/apache/druid/indexer/InputRowSerdeTest.java
@@ -20,7 +20,6 @@
 package org.apache.druid.indexer;
 
 import com.google.common.collect.ImmutableList;
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.data.input.InputRow;
 import org.apache.druid.data.input.MapBasedInputRow;
 import org.apache.druid.data.input.impl.DimensionsSpec;
@@ -38,6 +37,7 @@
 import org.apache.druid.query.aggregation.hyperloglog.HyperUniquesAggregatorFactory;
 import org.apache.druid.segment.ColumnSelectorFactory;
 import org.apache.druid.segment.column.ColumnType;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.easymock.EasyMock;
 import org.junit.Assert;
 import org.junit.Rule;
@@ -277,8 +277,8 @@ public void testDimensionNullOrDefaultForNumerics()
     long expected = 9 + 18 + 4 + 14 + 4 + 4 + 4 + 1;
 
     Assert.assertEquals(expected, result.length);
-    Assert.assertEquals(result[48], NullHandling.IS_NULL_BYTE);
-    Assert.assertEquals(result[52], NullHandling.IS_NULL_BYTE);
-    Assert.assertEquals(result[56], NullHandling.IS_NULL_BYTE);
+    Assert.assertEquals(result[48], TypeStrategies.IS_NULL_BYTE);
+    Assert.assertEquals(result[52], TypeStrategies.IS_NULL_BYTE);
+    Assert.assertEquals(result[56], TypeStrategies.IS_NULL_BYTE);
   }
 }
diff --git a/processing/src/main/java/org/apache/druid/common/config/NullHandling.java b/processing/src/main/java/org/apache/druid/common/config/NullHandling.java
deleted file mode 100644
index e2fe0d6f303b..000000000000
--- a/processing/src/main/java/org/apache/druid/common/config/NullHandling.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.apache.druid.common.config;
-
-import com.google.inject.Inject;
-
-/**
- * Some dead constants
- */
-public class NullHandling
-{
-  public static final byte IS_NULL_BYTE = (byte) 1;
-  public static final byte IS_NOT_NULL_BYTE = (byte) 0;
-
-  /**
-   * INSTANCE is injected using static injection to avoid adding JacksonInject annotations all over the code.
-   * See org.apache.druid.guice.NullHandlingModule for details.
-   * It does not take effect in all unit tests since we don't use Guice Injection.
-   */
-  @Inject
-  private static NullValueHandlingConfig INSTANCE;
-
-}
diff --git a/processing/src/main/java/org/apache/druid/common/config/NullValueHandlingConfig.java b/processing/src/main/java/org/apache/druid/common/config/NullValueHandlingConfig.java
deleted file mode 100644
index 2e578b24dc57..000000000000
--- a/processing/src/main/java/org/apache/druid/common/config/NullValueHandlingConfig.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.apache.druid.common.config;
-
-import com.fasterxml.jackson.annotation.JsonCreator;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import org.apache.druid.java.util.common.logger.Logger;
-
-public class NullValueHandlingConfig
-{
-  private static final Logger LOG = new Logger(NullValueHandlingConfig.class);
-  public static final String NULL_HANDLING_CONFIG_STRING = "druid.generic.useDefaultValueForNull";
-  public static final String THREE_VALUE_LOGIC_CONFIG_STRING = "druid.generic.useThreeValueLogicForNativeFilters";
-  public static final String NULL_HANDLING_DURING_STRING_CARDINALITY = "druid.generic.ignoreNullsForStringCardinality";
-
-  @JsonProperty("useDefaultValueForNull")
-  private final boolean useDefaultValuesForNull;
-
-  @JsonProperty("useThreeValueLogicForNativeFilters")
-  private final boolean useThreeValueLogicForNativeFilters;
-
-  @JsonProperty("ignoreNullsForStringCardinality")
-  private final boolean ignoreNullsForStringCardinality;
-
-  @JsonCreator
-  public NullValueHandlingConfig(
-      @JsonProperty("useDefaultValueForNull") Boolean useDefaultValuesForNull,
-      @JsonProperty("useThreeValueLogicForNativeFilters") Boolean useThreeValueLogicForNativeFilters,
-      @JsonProperty("ignoreNullsForStringCardinality") Boolean ignoreNullsForStringCardinality
-  )
-  {
-    if (useDefaultValuesForNull == null) {
-      this.useDefaultValuesForNull = Boolean.valueOf(System.getProperty(NULL_HANDLING_CONFIG_STRING, "false"));
-    } else {
-      this.useDefaultValuesForNull = useDefaultValuesForNull;
-    }
-    if (useThreeValueLogicForNativeFilters == null) {
-      this.useThreeValueLogicForNativeFilters = Boolean.valueOf(
-          System.getProperty(THREE_VALUE_LOGIC_CONFIG_STRING, "true")
-      );
-    } else {
-      this.useThreeValueLogicForNativeFilters = useThreeValueLogicForNativeFilters;
-    }
-    if (ignoreNullsForStringCardinality == null) {
-      this.ignoreNullsForStringCardinality = Boolean.valueOf(System.getProperty(
-          NULL_HANDLING_DURING_STRING_CARDINALITY,
-          "false"
-      ));
-    } else {
-      if (this.useDefaultValuesForNull) {
-        this.ignoreNullsForStringCardinality = ignoreNullsForStringCardinality;
-      } else {
-        this.ignoreNullsForStringCardinality = false;
-      }
-    }
-  }
-}
diff --git a/processing/src/main/java/org/apache/druid/frame/field/StringFieldWriter.java b/processing/src/main/java/org/apache/druid/frame/field/StringFieldWriter.java
index 5b304f8a0534..95a2426f8f8d 100644
--- a/processing/src/main/java/org/apache/druid/frame/field/StringFieldWriter.java
+++ b/processing/src/main/java/org/apache/druid/frame/field/StringFieldWriter.java
@@ -45,7 +45,7 @@ public class StringFieldWriter implements FieldWriter
   public static final byte NULL_ROW = 0x00;
 
   /**
-   * Different from the values in {@link org.apache.druid.common.config.NullHandling}, since we want to be able to
+   * Different from the values in {@link org.apache.druid.segment.column.TypeStrategies}, since we want to be able to
    * sort as bytes, and we want nulls to come before non-nulls.
    */
   public static final byte NULL_BYTE = 0x02;
diff --git a/processing/src/main/java/org/apache/druid/guice/NullHandlingModule.java b/processing/src/main/java/org/apache/druid/guice/NullHandlingModule.java
deleted file mode 100644
index b8be2e851a89..000000000000
--- a/processing/src/main/java/org/apache/druid/guice/NullHandlingModule.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.apache.druid.guice;
-
-import com.google.inject.Binder;
-import com.google.inject.Module;
-import org.apache.druid.common.config.NullHandling;
-import org.apache.druid.common.config.NullValueHandlingConfig;
-
-/**
- */
-public class NullHandlingModule implements Module
-{
-  @Override
-  public void configure(Binder binder)
-  {
-    JsonConfigProvider.bind(binder, "druid.generic", NullValueHandlingConfig.class);
-    binder.requestStaticInjection(NullHandling.class);
-  }
-}
diff --git a/processing/src/main/java/org/apache/druid/guice/StartupInjectorBuilder.java b/processing/src/main/java/org/apache/druid/guice/StartupInjectorBuilder.java
index 1d524a9a1e79..d71ba6d37532 100644
--- a/processing/src/main/java/org/apache/druid/guice/StartupInjectorBuilder.java
+++ b/processing/src/main/java/org/apache/druid/guice/StartupInjectorBuilder.java
@@ -23,7 +23,6 @@
 import com.google.inject.Inject;
 import com.google.inject.Injector;
 import com.google.inject.util.Providers;
-import org.apache.druid.common.config.NullValueHandlingConfig;
 import org.apache.druid.jackson.JacksonModule;
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.StringUtils;
@@ -51,13 +50,16 @@
  */
 public class StartupInjectorBuilder extends BaseInjectorBuilder<StartupInjectorBuilder>
 {
+
+  static final String NULL_HANDLING_CONFIG_STRING = "druid.generic.useDefaultValueForNull";
+  static final String THREE_VALUE_LOGIC_CONFIG_STRING = "druid.generic.useThreeValueLogicForNativeFilters";
+
   public StartupInjectorBuilder()
   {
     add(
         new DruidGuiceExtensions(),
         new JacksonModule(),
         new ConfigModule(),
-        new NullHandlingModule(),
         new ExpressionProcessingModule(),
         binder -> binder.bind(DruidSecondaryModule.class),
         binder -> binder.bind(PropertiesValidator.class) // this gets properties injected, later call to validate checks
@@ -131,25 +133,25 @@ public PropertiesValidator(Properties properties)
     public void validate()
     {
       final boolean defaultValueMode = Boolean.parseBoolean(
-          properties.getProperty(NullValueHandlingConfig.NULL_HANDLING_CONFIG_STRING, "false")
+          properties.getProperty(NULL_HANDLING_CONFIG_STRING, "false")
       );
       if (defaultValueMode) {
         final String docsLink = StringUtils.format("https://druid.apache.org/docs/%s/release-info/migr-ansi-sql-null", getVersionString());
         throw new ISE(
             "%s set to 'true', but has been removed, see %s for details for how to migrate to SQL compliant behavior",
-            NullValueHandlingConfig.NULL_HANDLING_CONFIG_STRING,
+            NULL_HANDLING_CONFIG_STRING,
             docsLink
         );
       }
 
       final boolean no3vl = !Boolean.parseBoolean(
-          properties.getProperty(NullValueHandlingConfig.THREE_VALUE_LOGIC_CONFIG_STRING, "true")
+          properties.getProperty(THREE_VALUE_LOGIC_CONFIG_STRING, "true")
       );
       if (no3vl) {
         final String docsLink = StringUtils.format("https://druid.apache.org/docs/%s/release-info/migr-ansi-sql-null", getVersionString());
         throw new ISE(
             "%s set to 'false', but has been removed, see %s for details for how to migrate to SQL compliant behavior",
-            NullValueHandlingConfig.THREE_VALUE_LOGIC_CONFIG_STRING,
+            THREE_VALUE_LOGIC_CONFIG_STRING,
             docsLink
         );
       }
diff --git a/processing/src/main/java/org/apache/druid/math/expr/ExpressionProcessing.java b/processing/src/main/java/org/apache/druid/math/expr/ExpressionProcessing.java
index 2387cea909f1..2e84b33d7bf5 100644
--- a/processing/src/main/java/org/apache/druid/math/expr/ExpressionProcessing.java
+++ b/processing/src/main/java/org/apache/druid/math/expr/ExpressionProcessing.java
@@ -23,7 +23,7 @@
 import com.google.inject.Inject;
 
 /**
- * Like {@link org.apache.druid.common.config.NullHandling}, except for expressions processing configs
+ * Expressions processing configs
  */
 public class ExpressionProcessing
 {
diff --git a/processing/src/main/java/org/apache/druid/query/aggregation/AbstractSerializablePairLongObjectDeltaEncodedStagedSerde.java b/processing/src/main/java/org/apache/druid/query/aggregation/AbstractSerializablePairLongObjectDeltaEncodedStagedSerde.java
index f276cd7b67f3..aaa3303f23e3 100644
--- a/processing/src/main/java/org/apache/druid/query/aggregation/AbstractSerializablePairLongObjectDeltaEncodedStagedSerde.java
+++ b/processing/src/main/java/org/apache/druid/query/aggregation/AbstractSerializablePairLongObjectDeltaEncodedStagedSerde.java
@@ -22,7 +22,7 @@
 import com.google.common.base.Preconditions;
 import com.google.common.primitives.Ints;
 import org.apache.druid.collections.SerializablePair;
-import org.apache.druid.common.config.NullHandling;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.apache.druid.segment.serde.cell.StagedSerde;
 import org.apache.druid.segment.serde.cell.StorableBuffer;
 
@@ -84,7 +84,7 @@ public void store(ByteBuffer byteBuffer)
         }
 
         if (rhsObject != null) {
-          byteBuffer.put(NullHandling.IS_NOT_NULL_BYTE);
+          byteBuffer.put(TypeStrategies.IS_NOT_NULL_BYTE);
           if (pairClass.isAssignableFrom(SerializablePairLongLong.class)) {
             byteBuffer.putLong((long) rhsObject);
           } else if (pairClass.isAssignableFrom(SerializablePairLongDouble.class)) {
@@ -93,7 +93,7 @@ public void store(ByteBuffer byteBuffer)
             byteBuffer.putFloat((float) rhsObject);
           }
         } else {
-          byteBuffer.put(NullHandling.IS_NULL_BYTE);
+          byteBuffer.put(TypeStrategies.IS_NULL_BYTE);
         }
       }
 
diff --git a/processing/src/main/java/org/apache/druid/query/aggregation/AbstractSerializablePairLongObjectSimpleStagedSerde.java b/processing/src/main/java/org/apache/druid/query/aggregation/AbstractSerializablePairLongObjectSimpleStagedSerde.java
index 8a7857163e46..1d826e65855b 100644
--- a/processing/src/main/java/org/apache/druid/query/aggregation/AbstractSerializablePairLongObjectSimpleStagedSerde.java
+++ b/processing/src/main/java/org/apache/druid/query/aggregation/AbstractSerializablePairLongObjectSimpleStagedSerde.java
@@ -21,7 +21,7 @@
 
 import com.google.common.base.Preconditions;
 import org.apache.druid.collections.SerializablePair;
-import org.apache.druid.common.config.NullHandling;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.apache.druid.segment.serde.cell.StagedSerde;
 import org.apache.druid.segment.serde.cell.StorableBuffer;
 
@@ -64,7 +64,7 @@ public void store(ByteBuffer byteBuffer)
         Preconditions.checkNotNull(value.getLhs(), "Long in %s must be non-null", pairCLass.getSimpleName());
         byteBuffer.putLong(value.getLhs());
         if (rhsObject != null) {
-          byteBuffer.put(NullHandling.IS_NOT_NULL_BYTE);
+          byteBuffer.put(TypeStrategies.IS_NOT_NULL_BYTE);
           if (pairCLass.isAssignableFrom(SerializablePairLongLong.class)) {
             byteBuffer.putLong((long) rhsObject);
           } else if (pairCLass.isAssignableFrom(SerializablePairLongDouble.class)) {
@@ -73,7 +73,7 @@ public void store(ByteBuffer byteBuffer)
             byteBuffer.putFloat((float) rhsObject);
           }
         } else {
-          byteBuffer.put(NullHandling.IS_NULL_BYTE);
+          byteBuffer.put(TypeStrategies.IS_NULL_BYTE);
         }
       }
 
diff --git a/processing/src/main/java/org/apache/druid/query/aggregation/NullableNumericBufferAggregator.java b/processing/src/main/java/org/apache/druid/query/aggregation/NullableNumericBufferAggregator.java
index 4a8ce6f792a4..963f298fe9be 100644
--- a/processing/src/main/java/org/apache/druid/query/aggregation/NullableNumericBufferAggregator.java
+++ b/processing/src/main/java/org/apache/druid/query/aggregation/NullableNumericBufferAggregator.java
@@ -19,11 +19,11 @@
 
 package org.apache.druid.query.aggregation;
 
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.guice.annotations.PublicApi;
 import org.apache.druid.query.monomorphicprocessing.RuntimeShapeInspector;
 import org.apache.druid.segment.BaseNullableColumnValueSelector;
 import org.apache.druid.segment.ColumnSelectorFactory;
+import org.apache.druid.segment.column.TypeStrategies;
 
 import javax.annotation.Nullable;
 import java.nio.ByteBuffer;
@@ -60,7 +60,7 @@ public NullableNumericBufferAggregator(BufferAggregator delegate, BaseNullableCo
   @Override
   public void init(ByteBuffer buf, int position)
   {
-    buf.put(position, NullHandling.IS_NULL_BYTE);
+    buf.put(position, TypeStrategies.IS_NULL_BYTE);
     delegate.init(buf, position + Byte.BYTES);
   }
 
@@ -69,8 +69,8 @@ public void aggregate(ByteBuffer buf, int position)
   {
     boolean isNotNull = !nullSelector.isNull();
     if (isNotNull) {
-      if (buf.get(position) == NullHandling.IS_NULL_BYTE) {
-        buf.put(position, NullHandling.IS_NOT_NULL_BYTE);
+      if (buf.get(position) == TypeStrategies.IS_NULL_BYTE) {
+        buf.put(position, TypeStrategies.IS_NOT_NULL_BYTE);
       }
       delegate.aggregate(buf, position + Byte.BYTES);
     }
@@ -80,7 +80,7 @@ public void aggregate(ByteBuffer buf, int position)
   @Nullable
   public Object get(ByteBuffer buf, int position)
   {
-    if (buf.get(position) == NullHandling.IS_NULL_BYTE) {
+    if (buf.get(position) == TypeStrategies.IS_NULL_BYTE) {
       return null;
     }
     return delegate.get(buf, position + Byte.BYTES);
@@ -89,7 +89,7 @@ public Object get(ByteBuffer buf, int position)
   @Override
   public float getFloat(ByteBuffer buf, int position)
   {
-    if (buf.get(position) == NullHandling.IS_NULL_BYTE) {
+    if (buf.get(position) == TypeStrategies.IS_NULL_BYTE) {
       throw new IllegalStateException("Cannot return float for Null Value");
     }
     return delegate.getFloat(buf, position + Byte.BYTES);
@@ -98,7 +98,7 @@ public float getFloat(ByteBuffer buf, int position)
   @Override
   public long getLong(ByteBuffer buf, int position)
   {
-    if (buf.get(position) == NullHandling.IS_NULL_BYTE) {
+    if (buf.get(position) == TypeStrategies.IS_NULL_BYTE) {
       throw new IllegalStateException("Cannot return long for Null Value");
     }
     return delegate.getLong(buf, position + Byte.BYTES);
@@ -107,7 +107,7 @@ public long getLong(ByteBuffer buf, int position)
   @Override
   public double getDouble(ByteBuffer buf, int position)
   {
-    if (buf.get(position) == NullHandling.IS_NULL_BYTE) {
+    if (buf.get(position) == TypeStrategies.IS_NULL_BYTE) {
       throw new IllegalStateException("Cannot return double for Null Value");
     }
     return delegate.getDouble(buf, position + Byte.BYTES);
@@ -116,7 +116,7 @@ public double getDouble(ByteBuffer buf, int position)
   @Override
   public boolean isNull(ByteBuffer buf, int position)
   {
-    return buf.get(position) == NullHandling.IS_NULL_BYTE || delegate.isNull(buf, position + Byte.BYTES);
+    return buf.get(position) == TypeStrategies.IS_NULL_BYTE || delegate.isNull(buf, position + Byte.BYTES);
   }
 
   @Override
diff --git a/processing/src/main/java/org/apache/druid/query/aggregation/NullableNumericVectorAggregator.java b/processing/src/main/java/org/apache/druid/query/aggregation/NullableNumericVectorAggregator.java
index cdc4499f013e..9a91176e2ab7 100644
--- a/processing/src/main/java/org/apache/druid/query/aggregation/NullableNumericVectorAggregator.java
+++ b/processing/src/main/java/org/apache/druid/query/aggregation/NullableNumericVectorAggregator.java
@@ -19,8 +19,8 @@
 
 package org.apache.druid.query.aggregation;
 
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.apache.druid.segment.vector.VectorValueSelector;
 
 import javax.annotation.Nullable;
@@ -68,7 +68,7 @@ public class NullableNumericVectorAggregator implements VectorAggregator
   @Override
   public void init(ByteBuffer buf, int position)
   {
-    buf.put(position, NullHandling.IS_NULL_BYTE);
+    buf.put(position, TypeStrategies.IS_NULL_BYTE);
     delegate.init(buf, position + Byte.BYTES);
   }
 
@@ -132,9 +132,9 @@ public void aggregate(ByteBuffer buf, int numRows, int[] positions, @Nullable in
   public Object get(ByteBuffer buf, int position)
   {
     switch (buf.get(position)) {
-      case NullHandling.IS_NULL_BYTE:
+      case TypeStrategies.IS_NULL_BYTE:
         return null;
-      case NullHandling.IS_NOT_NULL_BYTE:
+      case TypeStrategies.IS_NOT_NULL_BYTE:
         return delegate.get(buf, position + Byte.BYTES);
       default:
         // Corrupted byte?
@@ -156,14 +156,14 @@ public void close()
 
   private void doAggregate(ByteBuffer buf, int position, int start, int end)
   {
-    buf.put(position, NullHandling.IS_NOT_NULL_BYTE);
+    buf.put(position, TypeStrategies.IS_NOT_NULL_BYTE);
     delegate.aggregate(buf, position + Byte.BYTES, start, end);
   }
 
   private void doAggregate(ByteBuffer buf, int numRows, int[] positions, @Nullable int[] rows, int positionOffset)
   {
     for (int i = 0; i < numRows; i++) {
-      buf.put(positions[i] + positionOffset, NullHandling.IS_NOT_NULL_BYTE);
+      buf.put(positions[i] + positionOffset, TypeStrategies.IS_NOT_NULL_BYTE);
     }
 
     delegate.aggregate(buf, numRows, positions, rows, positionOffset + Byte.BYTES);
diff --git a/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongDoubleDeltaEncodedStagedSerde.java b/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongDoubleDeltaEncodedStagedSerde.java
index ce087ec623e0..d68d55e3f917 100644
--- a/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongDoubleDeltaEncodedStagedSerde.java
+++ b/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongDoubleDeltaEncodedStagedSerde.java
@@ -19,7 +19,7 @@
 
 package org.apache.druid.query.aggregation;
 
-import org.apache.druid.common.config.NullHandling;
+import org.apache.druid.segment.column.TypeStrategies;
 
 import javax.annotation.Nullable;
 import java.nio.ByteBuffer;
@@ -53,7 +53,7 @@ public SerializablePairLongDouble deserialize(ByteBuffer byteBuffer)
     lhs += minValue;
 
     Double rhs = null;
-    if (readOnlyBuffer.get() == NullHandling.IS_NOT_NULL_BYTE) {
+    if (readOnlyBuffer.get() == TypeStrategies.IS_NOT_NULL_BYTE) {
       rhs = readOnlyBuffer.getDouble();
     }
 
diff --git a/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongDoubleSimpleStagedSerde.java b/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongDoubleSimpleStagedSerde.java
index bf5c60e0c5b5..ee1de7457073 100644
--- a/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongDoubleSimpleStagedSerde.java
+++ b/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongDoubleSimpleStagedSerde.java
@@ -19,7 +19,7 @@
 
 package org.apache.druid.query.aggregation;
 
-import org.apache.druid.common.config.NullHandling;
+import org.apache.druid.segment.column.TypeStrategies;
 
 import javax.annotation.Nullable;
 import java.nio.ByteBuffer;
@@ -44,7 +44,7 @@ public SerializablePairLongDouble deserialize(ByteBuffer byteBuffer)
     long lhs = readOnlyBuffer.getLong();
 
     Double rhs = null;
-    if (readOnlyBuffer.get() == NullHandling.IS_NOT_NULL_BYTE) {
+    if (readOnlyBuffer.get() == TypeStrategies.IS_NOT_NULL_BYTE) {
       rhs = readOnlyBuffer.getDouble();
     }
 
diff --git a/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongFloatDeltaEncodedStagedSerde.java b/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongFloatDeltaEncodedStagedSerde.java
index 0f5e4f7f4a93..0b1846a0b87d 100644
--- a/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongFloatDeltaEncodedStagedSerde.java
+++ b/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongFloatDeltaEncodedStagedSerde.java
@@ -19,7 +19,7 @@
 
 package org.apache.druid.query.aggregation;
 
-import org.apache.druid.common.config.NullHandling;
+import org.apache.druid.segment.column.TypeStrategies;
 
 import javax.annotation.Nullable;
 import java.nio.ByteBuffer;
@@ -53,7 +53,7 @@ public SerializablePairLongFloat deserialize(ByteBuffer byteBuffer)
     lhs += minValue;
 
     Float rhs = null;
-    if (readOnlyBuffer.get() == NullHandling.IS_NOT_NULL_BYTE) {
+    if (readOnlyBuffer.get() == TypeStrategies.IS_NOT_NULL_BYTE) {
       rhs = readOnlyBuffer.getFloat();
     }
 
diff --git a/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongFloatSimpleStagedSerde.java b/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongFloatSimpleStagedSerde.java
index d8390974a95d..ec8ae074167c 100644
--- a/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongFloatSimpleStagedSerde.java
+++ b/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongFloatSimpleStagedSerde.java
@@ -19,7 +19,7 @@
 
 package org.apache.druid.query.aggregation;
 
-import org.apache.druid.common.config.NullHandling;
+import org.apache.druid.segment.column.TypeStrategies;
 
 import javax.annotation.Nullable;
 import java.nio.ByteBuffer;
@@ -44,7 +44,7 @@ public SerializablePairLongFloat deserialize(ByteBuffer byteBuffer)
     long lhs = readOnlyBuffer.getLong();
 
     Float rhs = null;
-    if (readOnlyBuffer.get() == NullHandling.IS_NOT_NULL_BYTE) {
+    if (readOnlyBuffer.get() == TypeStrategies.IS_NOT_NULL_BYTE) {
       rhs = readOnlyBuffer.getFloat();
     }
 
diff --git a/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongLongDeltaEncodedStagedSerde.java b/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongLongDeltaEncodedStagedSerde.java
index dad3711c3c73..7f0357d0265f 100644
--- a/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongLongDeltaEncodedStagedSerde.java
+++ b/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongLongDeltaEncodedStagedSerde.java
@@ -19,7 +19,7 @@
 
 package org.apache.druid.query.aggregation;
 
-import org.apache.druid.common.config.NullHandling;
+import org.apache.druid.segment.column.TypeStrategies;
 
 import javax.annotation.Nullable;
 import java.nio.ByteBuffer;
@@ -53,7 +53,7 @@ public SerializablePairLongLong deserialize(ByteBuffer byteBuffer)
     lhs += minValue;
 
     Long rhs = null;
-    if (readOnlyBuffer.get() == NullHandling.IS_NOT_NULL_BYTE) {
+    if (readOnlyBuffer.get() == TypeStrategies.IS_NOT_NULL_BYTE) {
       rhs = readOnlyBuffer.getLong();
     }
 
diff --git a/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongLongSimpleStagedSerde.java b/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongLongSimpleStagedSerde.java
index 587ce18a0b4c..2fd11b58c012 100644
--- a/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongLongSimpleStagedSerde.java
+++ b/processing/src/main/java/org/apache/druid/query/aggregation/SerializablePairLongLongSimpleStagedSerde.java
@@ -19,7 +19,7 @@
 
 package org.apache.druid.query.aggregation;
 
-import org.apache.druid.common.config.NullHandling;
+import org.apache.druid.segment.column.TypeStrategies;
 
 import javax.annotation.Nullable;
 import java.nio.ByteBuffer;
@@ -44,7 +44,7 @@ public SerializablePairLongLong deserialize(ByteBuffer byteBuffer)
     long lhs = readOnlyBuffer.getLong();
 
     Long rhs = null;
-    if (readOnlyBuffer.get() == NullHandling.IS_NOT_NULL_BYTE) {
+    if (readOnlyBuffer.get() == TypeStrategies.IS_NOT_NULL_BYTE) {
       rhs = readOnlyBuffer.getLong();
     }
 
diff --git a/processing/src/main/java/org/apache/druid/query/aggregation/SingleValueBufferAggregator.java b/processing/src/main/java/org/apache/druid/query/aggregation/SingleValueBufferAggregator.java
index 5b5b6b2e0542..f847dfed156c 100644
--- a/processing/src/main/java/org/apache/druid/query/aggregation/SingleValueBufferAggregator.java
+++ b/processing/src/main/java/org/apache/druid/query/aggregation/SingleValueBufferAggregator.java
@@ -19,7 +19,6 @@
 
 package org.apache.druid.query.aggregation;
 
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.error.DruidException;
 import org.apache.druid.error.InvalidInput;
 import org.apache.druid.segment.ColumnValueSelector;
@@ -47,7 +46,7 @@ public SingleValueBufferAggregator(ColumnValueSelector selector, ColumnType colu
   @Override
   public void init(ByteBuffer buf, int position)
   {
-    buf.put(position, NullHandling.IS_NULL_BYTE);
+    buf.put(position, TypeStrategies.IS_NULL_BYTE);
   }
 
   @Override
diff --git a/processing/src/main/java/org/apache/druid/query/aggregation/any/NumericAnyBufferAggregator.java b/processing/src/main/java/org/apache/druid/query/aggregation/any/NumericAnyBufferAggregator.java
index 1b7eeeaee092..cdaf5f0533bc 100644
--- a/processing/src/main/java/org/apache/druid/query/aggregation/any/NumericAnyBufferAggregator.java
+++ b/processing/src/main/java/org/apache/druid/query/aggregation/any/NumericAnyBufferAggregator.java
@@ -19,10 +19,10 @@
 
 package org.apache.druid.query.aggregation.any;
 
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.query.aggregation.BufferAggregator;
 import org.apache.druid.query.monomorphicprocessing.RuntimeShapeInspector;
 import org.apache.druid.segment.BaseNullableColumnValueSelector;
+import org.apache.druid.segment.column.TypeStrategies;
 
 import java.nio.ByteBuffer;
 
@@ -59,7 +59,7 @@ public NumericAnyBufferAggregator(TSelector valueSelector)
   @Override
   public void init(ByteBuffer buf, int position)
   {
-    buf.put(position, NullHandling.IS_NULL_BYTE);
+    buf.put(position, TypeStrategies.IS_NULL_BYTE);
     initValue(buf, position);
   }
 
@@ -69,16 +69,16 @@ public void aggregate(ByteBuffer buf, int position)
     if ((buf.get(position) & BYTE_FLAG_FOUND_MASK) != BYTE_FLAG_FOUND_MASK) {
       if (!valueSelector.isNull()) {
         putValue(buf, position);
-        buf.put(position, (byte) (BYTE_FLAG_FOUND_MASK | NullHandling.IS_NOT_NULL_BYTE));
+        buf.put(position, (byte) (BYTE_FLAG_FOUND_MASK | TypeStrategies.IS_NOT_NULL_BYTE));
       } else {
-        buf.put(position, (byte) (BYTE_FLAG_FOUND_MASK | NullHandling.IS_NULL_BYTE));
+        buf.put(position, (byte) (BYTE_FLAG_FOUND_MASK | TypeStrategies.IS_NULL_BYTE));
       }
     }
   }
 
   boolean isValueNull(ByteBuffer buf, int position)
   {
-    return (buf.get(position) & BYTE_FLAG_NULL_MASK) == NullHandling.IS_NULL_BYTE;
+    return (buf.get(position) & BYTE_FLAG_NULL_MASK) == TypeStrategies.IS_NULL_BYTE;
   }
 
   @Override
diff --git a/processing/src/main/java/org/apache/druid/query/aggregation/any/NumericAnyVectorAggregator.java b/processing/src/main/java/org/apache/druid/query/aggregation/any/NumericAnyVectorAggregator.java
index 5bfd877fd83d..9bd2131dfef7 100644
--- a/processing/src/main/java/org/apache/druid/query/aggregation/any/NumericAnyVectorAggregator.java
+++ b/processing/src/main/java/org/apache/druid/query/aggregation/any/NumericAnyVectorAggregator.java
@@ -20,8 +20,8 @@
 package org.apache.druid.query.aggregation.any;
 
 import com.google.common.annotations.VisibleForTesting;
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.query.aggregation.VectorAggregator;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.apache.druid.segment.vector.VectorValueSelector;
 
 import javax.annotation.Nullable;
@@ -64,7 +64,7 @@ public NumericAnyVectorAggregator(VectorValueSelector vectorValueSelector)
   @Override
   public void init(ByteBuffer buf, int position)
   {
-    buf.put(position, NullHandling.IS_NULL_BYTE);
+    buf.put(position, TypeStrategies.IS_NULL_BYTE);
     initValue(buf, position + FOUND_VALUE_OFFSET);
   }
 
@@ -85,7 +85,7 @@ public void aggregate(ByteBuffer buf, int position, int startRow, int endRow)
       }
       // There are no nulls, so try to put a value from the value selector
       if (putAnyValueFromRow(buf, position + FOUND_VALUE_OFFSET, startRow, endRow)) {
-        buf.put(position, (byte) (BYTE_FLAG_FOUND_MASK | NullHandling.IS_NOT_NULL_BYTE));
+        buf.put(position, (byte) (BYTE_FLAG_FOUND_MASK | TypeStrategies.IS_NOT_NULL_BYTE));
       }
     }
   }
@@ -123,11 +123,11 @@ public void close()
   @VisibleForTesting
   boolean isValueNull(ByteBuffer buf, int position)
   {
-    return (buf.get(position) & BYTE_FLAG_NULL_MASK) == NullHandling.IS_NULL_BYTE;
+    return (buf.get(position) & BYTE_FLAG_NULL_MASK) == TypeStrategies.IS_NULL_BYTE;
   }
 
   private void putNull(ByteBuffer buf, int position)
   {
-    buf.put(position, (byte) (BYTE_FLAG_FOUND_MASK | NullHandling.IS_NULL_BYTE));
+    buf.put(position, (byte) (BYTE_FLAG_FOUND_MASK | TypeStrategies.IS_NULL_BYTE));
   }
 }
diff --git a/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/DoubleFirstLastVectorAggregator.java b/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/DoubleFirstLastVectorAggregator.java
index fe87804f463f..acb4514886a9 100644
--- a/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/DoubleFirstLastVectorAggregator.java
+++ b/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/DoubleFirstLastVectorAggregator.java
@@ -19,8 +19,8 @@
 
 package org.apache.druid.query.aggregation.firstlast;
 
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.query.aggregation.SerializablePairLongDouble;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.apache.druid.segment.vector.VectorObjectSelector;
 import org.apache.druid.segment.vector.VectorValueSelector;
 
@@ -60,7 +60,7 @@ public void init(ByteBuffer buf, int position)
     buf.putLong(position, selectionPredicate.initValue());
     buf.put(
         position + NULLITY_OFFSET,
-        NullHandling.IS_NULL_BYTE
+        TypeStrategies.IS_NULL_BYTE
     );
     buf.putDouble(position + VALUE_OFFSET, 0.0D);
   }
@@ -70,7 +70,7 @@ public void init(ByteBuffer buf, int position)
   public Object get(ByteBuffer buf, int position)
   {
     long time = buf.getLong(position);
-    if (buf.get(position + NULLITY_OFFSET) == NullHandling.IS_NULL_BYTE) {
+    if (buf.get(position + NULLITY_OFFSET) == TypeStrategies.IS_NULL_BYTE) {
       return new SerializablePairLongDouble(time, null);
     }
     return new SerializablePairLongDouble(time, buf.getDouble(position + VALUE_OFFSET));
@@ -80,7 +80,7 @@ public Object get(ByteBuffer buf, int position)
   protected void putValue(ByteBuffer buf, int position, long time, Double value)
   {
     buf.putLong(position, time);
-    buf.put(position + NULLITY_OFFSET, NullHandling.IS_NOT_NULL_BYTE);
+    buf.put(position + NULLITY_OFFSET, TypeStrategies.IS_NOT_NULL_BYTE);
     buf.putDouble(position + VALUE_OFFSET, value);
   }
 
@@ -88,7 +88,7 @@ protected void putValue(ByteBuffer buf, int position, long time, Double value)
   protected void putValue(ByteBuffer buf, int position, long time, VectorValueSelector valueSelector, int index)
   {
     buf.putLong(position, time);
-    buf.put(position + NULLITY_OFFSET, NullHandling.IS_NOT_NULL_BYTE);
+    buf.put(position + NULLITY_OFFSET, TypeStrategies.IS_NOT_NULL_BYTE);
     buf.putDouble(position + VALUE_OFFSET, valueSelector.getDoubleVector()[index]);
   }
 
@@ -96,7 +96,7 @@ protected void putValue(ByteBuffer buf, int position, long time, VectorValueSele
   protected void putNull(ByteBuffer buf, int position, long time)
   {
     buf.putLong(position, time);
-    buf.put(position + NULLITY_OFFSET, NullHandling.IS_NULL_BYTE);
+    buf.put(position + NULLITY_OFFSET, TypeStrategies.IS_NULL_BYTE);
     buf.putDouble(position + VALUE_OFFSET, 0.0D);
 
   }
diff --git a/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/FloatFirstLastVectorAggregator.java b/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/FloatFirstLastVectorAggregator.java
index 6c9caa196b32..1b7d280837ad 100644
--- a/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/FloatFirstLastVectorAggregator.java
+++ b/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/FloatFirstLastVectorAggregator.java
@@ -19,8 +19,8 @@
 
 package org.apache.druid.query.aggregation.firstlast;
 
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.query.aggregation.SerializablePairLongFloat;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.apache.druid.segment.vector.VectorObjectSelector;
 import org.apache.druid.segment.vector.VectorValueSelector;
 
@@ -60,7 +60,7 @@ public void init(ByteBuffer buf, int position)
     buf.putLong(position, selectionPredicate.initValue());
     buf.put(
         position + NULLITY_OFFSET,
-        NullHandling.IS_NULL_BYTE
+        TypeStrategies.IS_NULL_BYTE
     );
     buf.putFloat(position + VALUE_OFFSET, 0.0F);
   }
@@ -70,7 +70,7 @@ public void init(ByteBuffer buf, int position)
   public Object get(ByteBuffer buf, int position)
   {
     long time = buf.getLong(position);
-    if (buf.get(position + NULLITY_OFFSET) == NullHandling.IS_NULL_BYTE) {
+    if (buf.get(position + NULLITY_OFFSET) == TypeStrategies.IS_NULL_BYTE) {
       return new SerializablePairLongFloat(time, null);
     }
     return new SerializablePairLongFloat(time, buf.getFloat(position + VALUE_OFFSET));
@@ -80,7 +80,7 @@ public Object get(ByteBuffer buf, int position)
   protected void putValue(ByteBuffer buf, int position, long time, Float value)
   {
     buf.putLong(position, time);
-    buf.put(position + NULLITY_OFFSET, NullHandling.IS_NOT_NULL_BYTE);
+    buf.put(position + NULLITY_OFFSET, TypeStrategies.IS_NOT_NULL_BYTE);
     buf.putFloat(position + VALUE_OFFSET, value);
   }
 
@@ -88,7 +88,7 @@ protected void putValue(ByteBuffer buf, int position, long time, Float value)
   protected void putValue(ByteBuffer buf, int position, long time, VectorValueSelector valueSelector, int index)
   {
     buf.putLong(position, time);
-    buf.put(position + NULLITY_OFFSET, NullHandling.IS_NOT_NULL_BYTE);
+    buf.put(position + NULLITY_OFFSET, TypeStrategies.IS_NOT_NULL_BYTE);
     buf.putFloat(position + VALUE_OFFSET, valueSelector.getFloatVector()[index]);
   }
 
@@ -96,7 +96,7 @@ protected void putValue(ByteBuffer buf, int position, long time, VectorValueSele
   protected void putNull(ByteBuffer buf, int position, long time)
   {
     buf.putLong(position, time);
-    buf.put(position + NULLITY_OFFSET, NullHandling.IS_NULL_BYTE);
+    buf.put(position + NULLITY_OFFSET, TypeStrategies.IS_NULL_BYTE);
     buf.putFloat(position + VALUE_OFFSET, 0.0F);
   }
 
diff --git a/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/LongFirstLastVectorAggregator.java b/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/LongFirstLastVectorAggregator.java
index fa3398ab9255..90ef096b84d2 100644
--- a/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/LongFirstLastVectorAggregator.java
+++ b/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/LongFirstLastVectorAggregator.java
@@ -19,8 +19,8 @@
 
 package org.apache.druid.query.aggregation.firstlast;
 
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.query.aggregation.SerializablePairLongLong;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.apache.druid.segment.vector.VectorObjectSelector;
 import org.apache.druid.segment.vector.VectorValueSelector;
 
@@ -60,7 +60,7 @@ public void init(ByteBuffer buf, int position)
     buf.putLong(position, selectionPredicate.initValue());
     buf.put(
         position + NULLITY_OFFSET,
-        NullHandling.IS_NULL_BYTE
+        TypeStrategies.IS_NULL_BYTE
     );
     buf.putLong(position + VALUE_OFFSET, 0L);
   }
@@ -70,7 +70,7 @@ public void init(ByteBuffer buf, int position)
   public Object get(ByteBuffer buf, int position)
   {
     long time = buf.getLong(position);
-    if (buf.get(position + NULLITY_OFFSET) == NullHandling.IS_NULL_BYTE) {
+    if (buf.get(position + NULLITY_OFFSET) == TypeStrategies.IS_NULL_BYTE) {
       return new SerializablePairLongLong(time, null);
     }
     return new SerializablePairLongLong(time, buf.getLong(position + VALUE_OFFSET));
@@ -80,7 +80,7 @@ public Object get(ByteBuffer buf, int position)
   protected void putValue(ByteBuffer buf, int position, long time, Long value)
   {
     buf.putLong(position, time);
-    buf.put(position + NULLITY_OFFSET, NullHandling.IS_NOT_NULL_BYTE);
+    buf.put(position + NULLITY_OFFSET, TypeStrategies.IS_NOT_NULL_BYTE);
     buf.putLong(position + VALUE_OFFSET, value);
   }
 
@@ -88,7 +88,7 @@ protected void putValue(ByteBuffer buf, int position, long time, Long value)
   protected void putValue(ByteBuffer buf, int position, long time, VectorValueSelector valueSelector, int index)
   {
     buf.putLong(position, time);
-    buf.put(position + NULLITY_OFFSET, NullHandling.IS_NOT_NULL_BYTE);
+    buf.put(position + NULLITY_OFFSET, TypeStrategies.IS_NOT_NULL_BYTE);
     buf.putLong(position + VALUE_OFFSET, valueSelector.getLongVector()[index]);
   }
 
@@ -96,7 +96,7 @@ protected void putValue(ByteBuffer buf, int position, long time, VectorValueSele
   protected void putNull(ByteBuffer buf, int position, long time)
   {
     buf.putLong(position, time);
-    buf.put(position + NULLITY_OFFSET, NullHandling.IS_NULL_BYTE);
+    buf.put(position + NULLITY_OFFSET, TypeStrategies.IS_NULL_BYTE);
     buf.putLong(position + VALUE_OFFSET, 0L);
   }
 
diff --git a/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/SingleStringFirstLastDimensionVectorAggregator.java b/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/SingleStringFirstLastDimensionVectorAggregator.java
index f5db20355aff..7a85e100b1ba 100644
--- a/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/SingleStringFirstLastDimensionVectorAggregator.java
+++ b/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/SingleStringFirstLastDimensionVectorAggregator.java
@@ -19,10 +19,10 @@
 
 package org.apache.druid.query.aggregation.firstlast;
 
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.error.DruidException;
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.query.aggregation.SerializablePairLongString;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.apache.druid.segment.vector.SingleValueDimensionVectorSelector;
 import org.apache.druid.segment.vector.VectorValueSelector;
 
@@ -60,7 +60,7 @@ public void init(ByteBuffer buf, int position)
     buf.putLong(position, selectionPredicate.initValue());
     buf.put(
         position + NULLITY_OFFSET,
-        NullHandling.IS_NULL_BYTE
+        TypeStrategies.IS_NULL_BYTE
     );
     buf.putInt(position + VALUE_OFFSET, 0);
   }
@@ -74,7 +74,7 @@ public void init(ByteBuffer buf, int position)
   public Object get(ByteBuffer buf, int position)
   {
     long time = buf.getLong(position);
-    if (buf.get(position + NULLITY_OFFSET) == NullHandling.IS_NULL_BYTE) {
+    if (buf.get(position + NULLITY_OFFSET) == TypeStrategies.IS_NULL_BYTE) {
       return new SerializablePairLongString(time, null);
     }
     int index = buf.getInt(position + VALUE_OFFSET);
@@ -92,7 +92,7 @@ protected void putValue(ByteBuffer buf, int position, long time, String value)
   protected void putValue(ByteBuffer buf, int position, long time, VectorValueSelector valueSelector, int index)
   {
     buf.putLong(position, time);
-    buf.put(position + NULLITY_OFFSET, NullHandling.IS_NOT_NULL_BYTE);
+    buf.put(position + NULLITY_OFFSET, TypeStrategies.IS_NOT_NULL_BYTE);
     buf.putInt(
         position + VALUE_OFFSET,
         ((SingleValueDimensionVectorSelectorAdapter) valueSelector).singleValueDimensionVectorSelector.getRowVector()[index]
@@ -103,7 +103,7 @@ protected void putValue(ByteBuffer buf, int position, long time, VectorValueSele
   protected void putNull(ByteBuffer buf, int position, long time)
   {
     buf.putLong(position, time);
-    buf.put(position + NULLITY_OFFSET, NullHandling.IS_NULL_BYTE);
+    buf.put(position + NULLITY_OFFSET, TypeStrategies.IS_NULL_BYTE);
     buf.putInt(position + VALUE_OFFSET, 0);
   }
 
diff --git a/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/first/NumericFirstBufferAggregator.java b/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/first/NumericFirstBufferAggregator.java
index 701c2955f3b9..b815c7524400 100644
--- a/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/first/NumericFirstBufferAggregator.java
+++ b/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/first/NumericFirstBufferAggregator.java
@@ -20,11 +20,11 @@
 package org.apache.druid.query.aggregation.firstlast.first;
 
 import org.apache.druid.collections.SerializablePair;
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.query.aggregation.BufferAggregator;
 import org.apache.druid.query.monomorphicprocessing.RuntimeShapeInspector;
 import org.apache.druid.segment.BaseLongColumnValueSelector;
 import org.apache.druid.segment.ColumnValueSelector;
+import org.apache.druid.segment.column.TypeStrategies;
 
 import java.nio.ByteBuffer;
 
@@ -63,33 +63,33 @@ public NumericFirstBufferAggregator(BaseLongColumnValueSelector timeSelector, Co
   void updateTimeWithValue(ByteBuffer buf, int position, long time, ColumnValueSelector valueSelector)
   {
     buf.putLong(position, time);
-    buf.put(position + NULL_OFFSET, NullHandling.IS_NOT_NULL_BYTE);
+    buf.put(position + NULL_OFFSET, TypeStrategies.IS_NOT_NULL_BYTE);
     putValue(buf, position + VALUE_OFFSET, valueSelector);
   }
 
   void updateTimeWithValue(ByteBuffer buf, int position, long time, Number value)
   {
     buf.putLong(position, time);
-    buf.put(position + NULL_OFFSET, NullHandling.IS_NOT_NULL_BYTE);
+    buf.put(position + NULL_OFFSET, TypeStrategies.IS_NOT_NULL_BYTE);
     putValue(buf, position + VALUE_OFFSET, value);
   }
 
   void updateTimeWithNull(ByteBuffer buf, int position, long time)
   {
     buf.putLong(position, time);
-    buf.put(position + NULL_OFFSET, NullHandling.IS_NULL_BYTE);
+    buf.put(position + NULL_OFFSET, TypeStrategies.IS_NULL_BYTE);
   }
 
   boolean isValueNull(ByteBuffer buf, int position)
   {
-    return buf.get(position + NULL_OFFSET) == NullHandling.IS_NULL_BYTE;
+    return buf.get(position + NULL_OFFSET) == TypeStrategies.IS_NULL_BYTE;
   }
 
   @Override
   public void init(ByteBuffer buf, int position)
   {
     buf.putLong(position, Long.MAX_VALUE);
-    buf.put(position + NULL_OFFSET, NullHandling.IS_NULL_BYTE);
+    buf.put(position + NULL_OFFSET, TypeStrategies.IS_NULL_BYTE);
     initValue(buf, position + VALUE_OFFSET);
   }
 
diff --git a/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/last/NumericLastBufferAggregator.java b/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/last/NumericLastBufferAggregator.java
index 352ac17d00ad..cebddf6e6caa 100644
--- a/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/last/NumericLastBufferAggregator.java
+++ b/processing/src/main/java/org/apache/druid/query/aggregation/firstlast/last/NumericLastBufferAggregator.java
@@ -20,11 +20,11 @@
 package org.apache.druid.query.aggregation.firstlast.last;
 
 import org.apache.druid.collections.SerializablePair;
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.query.aggregation.BufferAggregator;
 import org.apache.druid.query.monomorphicprocessing.RuntimeShapeInspector;
 import org.apache.druid.segment.BaseLongColumnValueSelector;
 import org.apache.druid.segment.ColumnValueSelector;
+import org.apache.druid.segment.column.TypeStrategies;
 
 import java.nio.ByteBuffer;
 
@@ -65,34 +65,34 @@ public NumericLastBufferAggregator(BaseLongColumnValueSelector timeSelector, Col
 
   boolean isValueNull(ByteBuffer buf, int position)
   {
-    return buf.get(position + NULL_OFFSET) == NullHandling.IS_NULL_BYTE;
+    return buf.get(position + NULL_OFFSET) == TypeStrategies.IS_NULL_BYTE;
   }
 
   void updateTimeWithValue(ByteBuffer buf, int position, long time, ColumnValueSelector valueSelector)
   {
     buf.putLong(position, time);
-    buf.put(position + NULL_OFFSET, NullHandling.IS_NOT_NULL_BYTE);
+    buf.put(position + NULL_OFFSET, TypeStrategies.IS_NOT_NULL_BYTE);
     putValue(buf, position + VALUE_OFFSET, valueSelector);
   }
 
   void updateTimeWithValue(ByteBuffer buf, int position, long time, Number value)
   {
     buf.putLong(position, time);
-    buf.put(position + NULL_OFFSET, NullHandling.IS_NOT_NULL_BYTE);
+    buf.put(position + NULL_OFFSET, TypeStrategies.IS_NOT_NULL_BYTE);
     putValue(buf, position + VALUE_OFFSET, value);
   }
 
   void updateTimeWithNull(ByteBuffer buf, int position, long time)
   {
     buf.putLong(position, time);
-    buf.put(position + NULL_OFFSET, NullHandling.IS_NULL_BYTE);
+    buf.put(position + NULL_OFFSET, TypeStrategies.IS_NULL_BYTE);
   }
 
   @Override
   public void init(ByteBuffer buf, int position)
   {
     buf.putLong(position, Long.MIN_VALUE);
-    buf.put(position + NULL_OFFSET, NullHandling.IS_NULL_BYTE);
+    buf.put(position + NULL_OFFSET, TypeStrategies.IS_NULL_BYTE);
     initValue(buf, position + VALUE_OFFSET);
   }
 
diff --git a/processing/src/main/java/org/apache/druid/query/filter/SelectorDimFilter.java b/processing/src/main/java/org/apache/druid/query/filter/SelectorDimFilter.java
index afb25d7e370c..a03414970e69 100644
--- a/processing/src/main/java/org/apache/druid/query/filter/SelectorDimFilter.java
+++ b/processing/src/main/java/org/apache/druid/query/filter/SelectorDimFilter.java
@@ -27,9 +27,9 @@
 import com.google.common.collect.Range;
 import com.google.common.collect.RangeSet;
 import com.google.common.collect.TreeRangeSet;
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.query.cache.CacheKeyBuilder;
 import org.apache.druid.query.extraction.ExtractionFn;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.apache.druid.segment.filter.DimensionPredicateFilter;
 import org.apache.druid.segment.filter.SelectorFilter;
 
@@ -85,7 +85,7 @@ public byte[] getCacheKey()
         .appendByte(DimFilterUtils.STRING_SEPARATOR)
         .appendString(dimension)
         .appendByte(DimFilterUtils.STRING_SEPARATOR)
-        .appendByte(value == null ? NullHandling.IS_NULL_BYTE : NullHandling.IS_NOT_NULL_BYTE)
+        .appendByte(value == null ? TypeStrategies.IS_NULL_BYTE : TypeStrategies.IS_NOT_NULL_BYTE)
         .appendString(value)
         .appendByte(DimFilterUtils.STRING_SEPARATOR)
         .appendByteArray(extractionFn == null ? new byte[0] : extractionFn.getCacheKey())
diff --git a/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/GrouperBufferComparatorUtils.java b/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/GrouperBufferComparatorUtils.java
index 109ddb66f3d1..baba7bab4abd 100644
--- a/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/GrouperBufferComparatorUtils.java
+++ b/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/GrouperBufferComparatorUtils.java
@@ -20,7 +20,6 @@
 package org.apache.druid.query.groupby.epinephelinae;
 
 import com.google.common.primitives.Longs;
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.java.util.common.IAE;
 import org.apache.druid.query.aggregation.AggregatorFactory;
 import org.apache.druid.query.dimension.DimensionSpec;
@@ -29,6 +28,7 @@
 import org.apache.druid.query.ordering.StringComparator;
 import org.apache.druid.query.ordering.StringComparators;
 import org.apache.druid.segment.column.ColumnType;
+import org.apache.druid.segment.column.TypeStrategies;
 
 import javax.annotation.Nullable;
 import java.nio.ByteBuffer;
@@ -409,8 +409,8 @@ public static Grouper.BufferComparator makeNullHandlingBufferComparatorForNumeri
   )
   {
     return (lhsBuffer, rhsBuffer, lhsPosition, rhsPosition) -> {
-      boolean isLhsNull = (lhsBuffer.get(lhsPosition + keyBufferPosition) == NullHandling.IS_NULL_BYTE);
-      boolean isRhsNull = (rhsBuffer.get(rhsPosition + keyBufferPosition) == NullHandling.IS_NULL_BYTE);
+      boolean isLhsNull = (lhsBuffer.get(lhsPosition + keyBufferPosition) == TypeStrategies.IS_NULL_BYTE);
+      boolean isRhsNull = (rhsBuffer.get(rhsPosition + keyBufferPosition) == TypeStrategies.IS_NULL_BYTE);
       if (isLhsNull && isRhsNull) {
         // Both are null
         return 0;
diff --git a/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/RowBasedGrouperHelper.java b/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/RowBasedGrouperHelper.java
index 0f64988ddf2e..665eadf7de6c 100644
--- a/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/RowBasedGrouperHelper.java
+++ b/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/RowBasedGrouperHelper.java
@@ -34,7 +34,6 @@
 import it.unimi.dsi.fastutil.ints.IntArrays;
 import it.unimi.dsi.fastutil.objects.Object2IntMap;
 import org.apache.druid.collections.ReferenceCountingResourceHolder;
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.common.guava.SettableSupplier;
 import org.apache.druid.common.utils.IntArrayUtils;
 import org.apache.druid.error.DruidException;
@@ -81,6 +80,7 @@
 import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.column.RowSignature;
 import org.apache.druid.segment.column.TypeSignature;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.apache.druid.segment.column.ValueType;
 import org.apache.druid.segment.data.IndexedInts;
 import org.apache.druid.segment.filter.Filters;
@@ -2166,9 +2166,9 @@ public boolean putToKeyBuffer(RowBasedKey key, int idx)
       {
         Object val = key.getKey()[idx];
         if (val == null) {
-          keyBuffer.put(NullHandling.IS_NULL_BYTE);
+          keyBuffer.put(TypeStrategies.IS_NULL_BYTE);
         } else {
-          keyBuffer.put(NullHandling.IS_NOT_NULL_BYTE);
+          keyBuffer.put(TypeStrategies.IS_NOT_NULL_BYTE);
         }
         return delegate.putToKeyBuffer(key, idx);
       }
@@ -2176,7 +2176,7 @@ public boolean putToKeyBuffer(RowBasedKey key, int idx)
       @Override
       public void getFromByteBuffer(ByteBuffer buffer, int initialOffset, int dimValIdx, Object[] dimValues)
       {
-        if (buffer.get(initialOffset + keyBufferPosition) == NullHandling.IS_NULL_BYTE) {
+        if (buffer.get(initialOffset + keyBufferPosition) == TypeStrategies.IS_NULL_BYTE) {
           dimValues[dimValIdx] = null;
         } else {
           delegate.getFromByteBuffer(buffer, initialOffset, dimValIdx, dimValues);
diff --git a/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/vector/NullableDoubleGroupByVectorColumnSelector.java b/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/vector/NullableDoubleGroupByVectorColumnSelector.java
index 7e429d25d817..e4992a9e38b2 100644
--- a/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/vector/NullableDoubleGroupByVectorColumnSelector.java
+++ b/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/vector/NullableDoubleGroupByVectorColumnSelector.java
@@ -20,9 +20,9 @@
 package org.apache.druid.query.groupby.epinephelinae.vector;
 
 import org.apache.datasketches.memory.WritableMemory;
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.query.groupby.ResultRow;
 import org.apache.druid.query.groupby.epinephelinae.collection.MemoryPointer;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.apache.druid.segment.vector.VectorValueSelector;
 
 public class NullableDoubleGroupByVectorColumnSelector implements GroupByVectorColumnSelector
@@ -54,12 +54,12 @@ public int writeKeys(
 
     if (nulls != null) {
       for (int i = startRow, j = keyOffset; i < endRow; i++, j += keySize) {
-        keySpace.putByte(j, nulls[i] ? NullHandling.IS_NULL_BYTE : NullHandling.IS_NOT_NULL_BYTE);
+        keySpace.putByte(j, nulls[i] ? TypeStrategies.IS_NULL_BYTE : TypeStrategies.IS_NOT_NULL_BYTE);
         keySpace.putDouble(j + 1, vector[i]);
       }
     } else {
       for (int i = startRow, j = keyOffset; i < endRow; i++, j += keySize) {
-        keySpace.putByte(j, NullHandling.IS_NOT_NULL_BYTE);
+        keySpace.putByte(j, TypeStrategies.IS_NOT_NULL_BYTE);
         keySpace.putDouble(j + 1, vector[i]);
       }
     }
@@ -75,7 +75,7 @@ public void writeKeyToResultRow(
       final int resultRowPosition
   )
   {
-    if (keyMemory.memory().getByte(keyMemory.position() + keyOffset) == NullHandling.IS_NULL_BYTE) {
+    if (keyMemory.memory().getByte(keyMemory.position() + keyOffset) == TypeStrategies.IS_NULL_BYTE) {
       resultRow.set(resultRowPosition, null);
     } else {
       resultRow.set(resultRowPosition, keyMemory.memory().getDouble(keyMemory.position() + keyOffset + 1));
diff --git a/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/vector/NullableFloatGroupByVectorColumnSelector.java b/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/vector/NullableFloatGroupByVectorColumnSelector.java
index 2717a205e3f6..1b8012b8d341 100644
--- a/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/vector/NullableFloatGroupByVectorColumnSelector.java
+++ b/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/vector/NullableFloatGroupByVectorColumnSelector.java
@@ -20,9 +20,9 @@
 package org.apache.druid.query.groupby.epinephelinae.vector;
 
 import org.apache.datasketches.memory.WritableMemory;
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.query.groupby.ResultRow;
 import org.apache.druid.query.groupby.epinephelinae.collection.MemoryPointer;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.apache.druid.segment.vector.VectorValueSelector;
 
 public class NullableFloatGroupByVectorColumnSelector implements GroupByVectorColumnSelector
@@ -54,12 +54,12 @@ public int writeKeys(
 
     if (nulls != null) {
       for (int i = startRow, j = keyOffset; i < endRow; i++, j += keySize) {
-        keySpace.putByte(j, nulls[i] ? NullHandling.IS_NULL_BYTE : NullHandling.IS_NOT_NULL_BYTE);
+        keySpace.putByte(j, nulls[i] ? TypeStrategies.IS_NULL_BYTE : TypeStrategies.IS_NOT_NULL_BYTE);
         keySpace.putFloat(j + 1, vector[i]);
       }
     } else {
       for (int i = startRow, j = keyOffset; i < endRow; i++, j += keySize) {
-        keySpace.putByte(j, NullHandling.IS_NOT_NULL_BYTE);
+        keySpace.putByte(j, TypeStrategies.IS_NOT_NULL_BYTE);
         keySpace.putFloat(j + 1, vector[i]);
       }
     }
@@ -75,7 +75,7 @@ public void writeKeyToResultRow(
       final int resultRowPosition
   )
   {
-    if (keyMemory.memory().getByte(keyMemory.position() + keyOffset) == NullHandling.IS_NULL_BYTE) {
+    if (keyMemory.memory().getByte(keyMemory.position() + keyOffset) == TypeStrategies.IS_NULL_BYTE) {
       resultRow.set(resultRowPosition, null);
     } else {
       resultRow.set(resultRowPosition, keyMemory.memory().getFloat(keyMemory.position() + keyOffset + 1));
diff --git a/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/vector/NullableLongGroupByVectorColumnSelector.java b/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/vector/NullableLongGroupByVectorColumnSelector.java
index dc221f04db17..fe08eb9fab18 100644
--- a/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/vector/NullableLongGroupByVectorColumnSelector.java
+++ b/processing/src/main/java/org/apache/druid/query/groupby/epinephelinae/vector/NullableLongGroupByVectorColumnSelector.java
@@ -20,9 +20,9 @@
 package org.apache.druid.query.groupby.epinephelinae.vector;
 
 import org.apache.datasketches.memory.WritableMemory;
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.query.groupby.ResultRow;
 import org.apache.druid.query.groupby.epinephelinae.collection.MemoryPointer;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.apache.druid.segment.vector.VectorValueSelector;
 
 public class NullableLongGroupByVectorColumnSelector implements GroupByVectorColumnSelector
@@ -54,12 +54,12 @@ public int writeKeys(
 
     if (nulls != null) {
       for (int i = startRow, j = keyOffset; i < endRow; i++, j += keySize) {
-        keySpace.putByte(j, nulls[i] ? NullHandling.IS_NULL_BYTE : NullHandling.IS_NOT_NULL_BYTE);
+        keySpace.putByte(j, nulls[i] ? TypeStrategies.IS_NULL_BYTE : TypeStrategies.IS_NOT_NULL_BYTE);
         keySpace.putLong(j + 1, vector[i]);
       }
     } else {
       for (int i = startRow, j = keyOffset; i < endRow; i++, j += keySize) {
-        keySpace.putByte(j, NullHandling.IS_NOT_NULL_BYTE);
+        keySpace.putByte(j, TypeStrategies.IS_NOT_NULL_BYTE);
         keySpace.putLong(j + 1, vector[i]);
       }
     }
@@ -75,7 +75,7 @@ public void writeKeyToResultRow(
       final int resultRowPosition
   )
   {
-    if (keyMemory.memory().getByte(keyMemory.position() + keyOffset) == NullHandling.IS_NULL_BYTE) {
+    if (keyMemory.memory().getByte(keyMemory.position() + keyOffset) == TypeStrategies.IS_NULL_BYTE) {
       resultRow.set(resultRowPosition, null);
     } else {
       resultRow.set(resultRowPosition, keyMemory.memory().getLong(keyMemory.position() + keyOffset + 1));
diff --git a/processing/src/main/java/org/apache/druid/segment/column/NullableTypeStrategy.java b/processing/src/main/java/org/apache/druid/segment/column/NullableTypeStrategy.java
index db6192669864..09deb9f48e61 100644
--- a/processing/src/main/java/org/apache/druid/segment/column/NullableTypeStrategy.java
+++ b/processing/src/main/java/org/apache/druid/segment/column/NullableTypeStrategy.java
@@ -20,7 +20,6 @@
 package org.apache.druid.segment.column;
 
 import it.unimi.dsi.fastutil.Hash;
-import org.apache.druid.common.config.NullHandling;
 
 import javax.annotation.CheckReturnValue;
 import javax.annotation.Nullable;
@@ -28,9 +27,9 @@
 import java.util.Comparator;
 
 /**
- * Wrapper of {@link TypeStrategy} for nullable types, which stores {@link NullHandling#IS_NULL_BYTE} or
- * {@link NullHandling#IS_NOT_NULL_BYTE} in the leading byte of any value, as appropriate. If the value is null, only
- * {@link NullHandling#IS_NULL_BYTE} will be set, otherwise, the value bytes will be written after the null byte.
+ * Wrapper of {@link TypeStrategy} for nullable types, which stores {@link TypeStrategies#IS_NULL_BYTE} or
+ * {@link TypeStrategies#IS_NOT_NULL_BYTE} in the leading byte of any value, as appropriate. If the value is null, only
+ * {@link TypeStrategies#IS_NULL_BYTE} will be set, otherwise, the value bytes will be written after the null byte.
  *
  * layout: | null (byte) | value (byte[]) |
  *
@@ -62,7 +61,7 @@ public int estimateSizeBytes(@Nullable T value)
   @Nullable
   public T read(ByteBuffer buffer)
   {
-    if ((buffer.get() & NullHandling.IS_NULL_BYTE) == NullHandling.IS_NULL_BYTE) {
+    if ((buffer.get() & TypeStrategies.IS_NULL_BYTE) == TypeStrategies.IS_NULL_BYTE) {
       return null;
     }
     return delegate.read(buffer);
@@ -76,10 +75,10 @@ public int write(ByteBuffer buffer, @Nullable T value, int maxSizeBytes)
     if (remaining >= 0) {
       // if we have room left, write the null byte and the value
       if (value == null) {
-        buffer.put(NullHandling.IS_NULL_BYTE);
+        buffer.put(TypeStrategies.IS_NULL_BYTE);
         return Byte.BYTES;
       }
-      buffer.put(NullHandling.IS_NOT_NULL_BYTE);
+      buffer.put(TypeStrategies.IS_NOT_NULL_BYTE);
       int written = delegate.write(buffer, value, maxSizeBytes - Byte.BYTES);
       return written < 0 ? written : Byte.BYTES + written;
     } else {
diff --git a/processing/src/main/java/org/apache/druid/segment/column/TypeSignature.java b/processing/src/main/java/org/apache/druid/segment/column/TypeSignature.java
index b1b5c25d9502..c0da42e329e0 100644
--- a/processing/src/main/java/org/apache/druid/segment/column/TypeSignature.java
+++ b/processing/src/main/java/org/apache/druid/segment/column/TypeSignature.java
@@ -109,8 +109,8 @@ public interface TypeSignature<Type extends TypeDescriptor>
   /**
    * A {@link NullableTypeStrategy} is a {@link TypeStrategy} which can handle reading and writing null values, at the
    * very high cost of an additional byte per value, of which a single bit is used to store
-   * {@link org.apache.druid.common.config.NullHandling#IS_NULL_BYTE} or
-   * {@link org.apache.druid.common.config.NullHandling#IS_NOT_NULL_BYTE} as appropriate.
+   * {@link TypeStrategies#IS_NULL_BYTE} or
+   * {@link TypeStrategies#IS_NOT_NULL_BYTE} as appropriate.
    *
    * This pattern is common among buffer aggregators, which don't have access to an external memory location for more
    * efficient tracking of null values and must store this information inline with the accumulated value.
diff --git a/processing/src/main/java/org/apache/druid/segment/column/TypeStrategies.java b/processing/src/main/java/org/apache/druid/segment/column/TypeStrategies.java
index 7ac8def99ec1..7099c7b7891f 100644
--- a/processing/src/main/java/org/apache/druid/segment/column/TypeStrategies.java
+++ b/processing/src/main/java/org/apache/druid/segment/column/TypeStrategies.java
@@ -23,7 +23,6 @@
 import com.google.common.collect.Ordering;
 import com.google.common.primitives.Floats;
 import com.google.common.primitives.Longs;
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.java.util.common.IAE;
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.StringUtils;
@@ -36,6 +35,9 @@
 
 public class TypeStrategies
 {
+  public static final byte IS_NULL_BYTE = (byte) 1;
+  public static final byte IS_NOT_NULL_BYTE = (byte) 0;
+  
   public static final int VALUE_OFFSET = Byte.BYTES;
   public static final int NULLABLE_LONG_SIZE = Byte.BYTES + Long.BYTES;
   public static final int NULLABLE_DOUBLE_SIZE = Byte.BYTES + Double.BYTES;
@@ -91,7 +93,7 @@ public static void registerComplex(String typeName, TypeStrategy<?> strategy)
   }
 
   /**
-   * Clear and set the 'null' byte of a nullable value to {@link NullHandling#IS_NULL_BYTE} to a {@link ByteBuffer} at
+   * Clear and set the 'null' byte of a nullable value to {@link TypeStrategies#IS_NULL_BYTE} to a {@link ByteBuffer} at
    * the supplied position. This method does not change the buffer position, limit, or mark, because it does not expect
    * to own the buffer given to it (i.e. buffer aggs)
    *
@@ -104,29 +106,29 @@ public static void registerComplex(String typeName, TypeStrategy<?> strategy)
    */
   public static int writeNull(ByteBuffer buffer, int offset)
   {
-    buffer.put(offset, NullHandling.IS_NULL_BYTE);
+    buffer.put(offset, IS_NULL_BYTE);
     return 1;
   }
 
   /**
-   * Checks if a 'nullable' value's null byte is set to {@link NullHandling#IS_NULL_BYTE}. This method will mask the
+   * Checks if a 'nullable' value's null byte is set to {@link TypeStrategies#IS_NULL_BYTE}. This method will mask the
    * value of the null byte to only check if the null bit is set, meaning that the higher bits can be utilized for
    * flags as necessary (e.g. using high bits to indicate if the value has been set or not for aggregators).
    *
    * Note that writing nullable values with the methods of {@link Types} will always clear and set the null byte to
-   * either {@link NullHandling#IS_NULL_BYTE} or {@link NullHandling#IS_NOT_NULL_BYTE}, losing any flag bits.
+   * either {@link TypeStrategies#IS_NULL_BYTE} or {@link TypeStrategies#IS_NOT_NULL_BYTE}, losing any flag bits.
    *
    * layout: | null (byte) | value |
    */
   public static boolean isNullableNull(ByteBuffer buffer, int offset)
   {
     // use & so that callers can use the high bits of the null byte to pack additional information if necessary
-    return (buffer.get(offset) & NullHandling.IS_NULL_BYTE) == NullHandling.IS_NULL_BYTE;
+    return (buffer.get(offset) & IS_NULL_BYTE) == IS_NULL_BYTE;
   }
 
   /**
    * Write a non-null long value to a {@link ByteBuffer} at the supplied offset. The first byte is always cleared and
-   * set to {@link NullHandling#IS_NOT_NULL_BYTE}, the long value is written in the next 8 bytes.
+   * set to {@link TypeStrategies#IS_NOT_NULL_BYTE}, the long value is written in the next 8 bytes.
    *
    * layout: | null (byte) | long |
    *
@@ -137,7 +139,7 @@ public static boolean isNullableNull(ByteBuffer buffer, int offset)
    */
   public static int writeNotNullNullableLong(ByteBuffer buffer, int offset, long value)
   {
-    buffer.put(offset++, NullHandling.IS_NOT_NULL_BYTE);
+    buffer.put(offset++, IS_NOT_NULL_BYTE);
     buffer.putLong(offset, value);
     return NULLABLE_LONG_SIZE;
   }
@@ -158,7 +160,7 @@ public static long readNotNullNullableLong(ByteBuffer buffer, int offset)
 
   /**
    * Write a non-null double value to a {@link ByteBuffer} at the supplied offset. The first byte is always cleared and
-   * set to {@link NullHandling#IS_NOT_NULL_BYTE}, the double value is written in the next 8 bytes.
+   * set to {@link TypeStrategies#IS_NOT_NULL_BYTE}, the double value is written in the next 8 bytes.
    *
    * layout: | null (byte) | double |
    *
@@ -169,7 +171,7 @@ public static long readNotNullNullableLong(ByteBuffer buffer, int offset)
    */
   public static int writeNotNullNullableDouble(ByteBuffer buffer, int offset, double value)
   {
-    buffer.put(offset++, NullHandling.IS_NOT_NULL_BYTE);
+    buffer.put(offset++, IS_NOT_NULL_BYTE);
     buffer.putDouble(offset, value);
     return NULLABLE_DOUBLE_SIZE;
   }
@@ -190,7 +192,7 @@ public static double readNotNullNullableDouble(ByteBuffer buffer, int offset)
 
   /**
    * Write a non-null float value to a {@link ByteBuffer} at the supplied offset. The first byte is always cleared and
-   * set to {@link NullHandling#IS_NOT_NULL_BYTE}, the float value is written in the next 4 bytes.
+   * set to {@link TypeStrategies#IS_NOT_NULL_BYTE}, the float value is written in the next 4 bytes.
    *
    * layout: | null (byte) | float |
    *
@@ -201,7 +203,7 @@ public static double readNotNullNullableDouble(ByteBuffer buffer, int offset)
    */
   public static int writeNotNullNullableFloat(ByteBuffer buffer, int offset, float value)
   {
-    buffer.put(offset++, NullHandling.IS_NOT_NULL_BYTE);
+    buffer.put(offset++, IS_NOT_NULL_BYTE);
     buffer.putFloat(offset, value);
     return NULLABLE_FLOAT_SIZE;
   }
diff --git a/processing/src/main/java/org/apache/druid/segment/column/TypeStrategy.java b/processing/src/main/java/org/apache/druid/segment/column/TypeStrategy.java
index 1d75d9fde74b..8020c423856e 100644
--- a/processing/src/main/java/org/apache/druid/segment/column/TypeStrategy.java
+++ b/processing/src/main/java/org/apache/druid/segment/column/TypeStrategy.java
@@ -20,7 +20,6 @@
 package org.apache.druid.segment.column;
 
 import it.unimi.dsi.fastutil.Hash;
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.error.DruidException;
 
 import java.nio.ByteBuffer;
@@ -41,8 +40,8 @@
  * All implementations of this mechanism support reading and writing ONLY non-null values. To handle nulls inline with
  * your values, consider {@link NullableTypeStrategy}, which might be acceptable to use if you need to read and write
  * nullable values, AND, you have enough memory to burn a full byte for every value you want to store. It will store
- * values with a leading byte containing either {@link NullHandling#IS_NULL_BYTE} or
- * {@link NullHandling#IS_NOT_NULL_BYTE} as appropriate. If you have a lot of values to write and a lot of nulls,
+ * values with a leading byte containing either {@link TypeStrategies#IS_NULL_BYTE} or
+ * {@link TypeStrategies#IS_NOT_NULL_BYTE} as appropriate. If you have a lot of values to write and a lot of nulls,
  * consider alternative approaches to tracking your nulls instead.
  *
  * This mechanism allows using the natural {@link ByteBuffer#position()} and modify the underlying position as they
diff --git a/processing/src/main/java/org/apache/druid/segment/data/FixedIndexed.java b/processing/src/main/java/org/apache/druid/segment/data/FixedIndexed.java
index 3ba90c51332b..10691d9e9b00 100644
--- a/processing/src/main/java/org/apache/druid/segment/data/FixedIndexed.java
+++ b/processing/src/main/java/org/apache/druid/segment/data/FixedIndexed.java
@@ -23,8 +23,8 @@
 import com.google.common.base.Supplier;
 import it.unimi.dsi.fastutil.ints.IntIntImmutablePair;
 import it.unimi.dsi.fastutil.ints.IntIntPair;
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.query.monomorphicprocessing.RuntimeShapeInspector;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.apache.druid.segment.column.TypeStrategy;
 
 import javax.annotation.Nullable;
@@ -59,7 +59,7 @@ public static <T> Supplier<FixedIndexed<T>> read(ByteBuffer bb, TypeStrategy<T>
     final byte version = buffer.get();
     Preconditions.checkState(version == 0, "Unknown version [%s]", version);
     final byte flags = buffer.get();
-    final boolean hasNull = (flags & NullHandling.IS_NULL_BYTE) == NullHandling.IS_NULL_BYTE ? true : false;
+    final boolean hasNull = (flags & TypeStrategies.IS_NULL_BYTE) == TypeStrategies.IS_NULL_BYTE ? true : false;
     final boolean isSorted = (flags & IS_SORTED_MASK) == IS_SORTED_MASK ? true : false;
     Preconditions.checkState(!(hasNull && !isSorted), "cannot have null values if not sorted");
     final int size = buffer.getInt() + (hasNull ? 1 : 0);
diff --git a/processing/src/main/java/org/apache/druid/segment/data/FixedIndexedWriter.java b/processing/src/main/java/org/apache/druid/segment/data/FixedIndexedWriter.java
index c93b1ecc730b..4bac89fa151f 100644
--- a/processing/src/main/java/org/apache/druid/segment/data/FixedIndexedWriter.java
+++ b/processing/src/main/java/org/apache/druid/segment/data/FixedIndexedWriter.java
@@ -19,10 +19,10 @@
 
 package org.apache.druid.segment.data;
 
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.error.DruidException;
 import org.apache.druid.io.Channels;
 import org.apache.druid.java.util.common.io.smoosh.FileSmoosher;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.apache.druid.segment.column.TypeStrategy;
 import org.apache.druid.segment.writeout.SegmentWriteOutMedium;
 import org.apache.druid.segment.writeout.WriteOutBytes;
@@ -137,7 +137,7 @@ public void writeTo(
     scratch.put((byte) 0);
     byte flags = 0x00;
     if (hasNulls) {
-      flags = (byte) (flags | NullHandling.IS_NULL_BYTE);
+      flags = (byte) (flags | TypeStrategies.IS_NULL_BYTE);
     }
     if (isSorted) {
       flags = (byte) (flags | FixedIndexed.IS_SORTED_MASK);
diff --git a/processing/src/main/java/org/apache/druid/segment/data/FrontCodedIndexed.java b/processing/src/main/java/org/apache/druid/segment/data/FrontCodedIndexed.java
index 58231fd26029..bd541404b1d5 100644
--- a/processing/src/main/java/org/apache/druid/segment/data/FrontCodedIndexed.java
+++ b/processing/src/main/java/org/apache/druid/segment/data/FrontCodedIndexed.java
@@ -21,11 +21,11 @@
 
 import com.google.common.base.Preconditions;
 import com.google.common.base.Supplier;
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.java.util.common.IAE;
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.query.monomorphicprocessing.RuntimeShapeInspector;
+import org.apache.druid.segment.column.TypeStrategies;
 
 import javax.annotation.Nullable;
 import java.nio.ByteBuffer;
@@ -100,7 +100,7 @@ public static Supplier<FrontCodedIndexed> read(ByteBuffer buffer, ByteOrder orde
     final byte version = orderedBuffer.get();
     Preconditions.checkArgument(version == V0 || version == V1, "only V0 and V1 exist, encountered " + version);
     final int bucketSize = Byte.toUnsignedInt(orderedBuffer.get());
-    final boolean hasNull = NullHandling.IS_NULL_BYTE == orderedBuffer.get();
+    final boolean hasNull = TypeStrategies.IS_NULL_BYTE == orderedBuffer.get();
     final int numValues = VByte.readInt(orderedBuffer);
     // size of offsets + values
     final int size = VByte.readInt(orderedBuffer);
diff --git a/processing/src/main/java/org/apache/druid/segment/data/FrontCodedIndexedWriter.java b/processing/src/main/java/org/apache/druid/segment/data/FrontCodedIndexedWriter.java
index 707e3894793a..b2fb35832154 100644
--- a/processing/src/main/java/org/apache/druid/segment/data/FrontCodedIndexedWriter.java
+++ b/processing/src/main/java/org/apache/druid/segment/data/FrontCodedIndexedWriter.java
@@ -20,13 +20,13 @@
 package org.apache.druid.segment.data;
 
 import com.google.common.primitives.Ints;
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.error.DruidException;
 import org.apache.druid.io.Channels;
 import org.apache.druid.java.util.common.IAE;
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.java.util.common.io.smoosh.FileSmoosher;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.apache.druid.segment.writeout.SegmentWriteOutMedium;
 import org.apache.druid.segment.writeout.WriteOutBytes;
 
@@ -177,7 +177,7 @@ public void writeTo(WritableByteChannel channel, FileSmoosher smoosher) throws I
     resetScratch();
     scratch.put(version);
     scratch.put((byte) bucketSize);
-    scratch.put(hasNulls ? NullHandling.IS_NULL_BYTE : NullHandling.IS_NOT_NULL_BYTE);
+    scratch.put(hasNulls ? TypeStrategies.IS_NULL_BYTE : TypeStrategies.IS_NOT_NULL_BYTE);
     VByte.writeInt(scratch, numWritten);
     VByte.writeInt(scratch, Ints.checkedCast(headerOut.size() + valuesOut.size()));
     scratch.flip();
diff --git a/processing/src/main/java/org/apache/druid/segment/data/FrontCodedIntArrayIndexed.java b/processing/src/main/java/org/apache/druid/segment/data/FrontCodedIntArrayIndexed.java
index 9543bdfb3287..c8e1893fb4d0 100644
--- a/processing/src/main/java/org/apache/druid/segment/data/FrontCodedIntArrayIndexed.java
+++ b/processing/src/main/java/org/apache/druid/segment/data/FrontCodedIntArrayIndexed.java
@@ -21,10 +21,10 @@
 
 import com.google.common.base.Preconditions;
 import com.google.common.base.Supplier;
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.query.monomorphicprocessing.RuntimeShapeInspector;
+import org.apache.druid.segment.column.TypeStrategies;
 
 import javax.annotation.Nullable;
 import java.nio.ByteBuffer;
@@ -79,7 +79,7 @@ public static Supplier<FrontCodedIntArrayIndexed> read(ByteBuffer buffer, ByteOr
     final byte version = orderedBuffer.get();
     Preconditions.checkArgument(version == 0, "only V0 exists, encountered " + version);
     final int bucketSize = Byte.toUnsignedInt(orderedBuffer.get());
-    final boolean hasNull = NullHandling.IS_NULL_BYTE == orderedBuffer.get();
+    final boolean hasNull = TypeStrategies.IS_NULL_BYTE == orderedBuffer.get();
     final int numValues = VByte.readInt(orderedBuffer);
     // size of offsets + values
     final int size = VByte.readInt(orderedBuffer);
diff --git a/processing/src/main/java/org/apache/druid/segment/data/FrontCodedIntArrayIndexedWriter.java b/processing/src/main/java/org/apache/druid/segment/data/FrontCodedIntArrayIndexedWriter.java
index 50e350f3d640..b02ca882bcd0 100644
--- a/processing/src/main/java/org/apache/druid/segment/data/FrontCodedIntArrayIndexedWriter.java
+++ b/processing/src/main/java/org/apache/druid/segment/data/FrontCodedIntArrayIndexedWriter.java
@@ -20,12 +20,12 @@
 package org.apache.druid.segment.data;
 
 import com.google.common.primitives.Ints;
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.error.DruidException;
 import org.apache.druid.io.Channels;
 import org.apache.druid.java.util.common.IAE;
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.io.smoosh.FileSmoosher;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.apache.druid.segment.writeout.SegmentWriteOutMedium;
 import org.apache.druid.segment.writeout.WriteOutBytes;
 
@@ -186,7 +186,7 @@ public void writeTo(WritableByteChannel channel, FileSmoosher smoosher) throws I
     // version 0
     scratch.put((byte) 0);
     scratch.put((byte) bucketSize);
-    scratch.put(hasNulls ? NullHandling.IS_NULL_BYTE : NullHandling.IS_NOT_NULL_BYTE);
+    scratch.put(hasNulls ? TypeStrategies.IS_NULL_BYTE : TypeStrategies.IS_NOT_NULL_BYTE);
     VByte.writeInt(scratch, numWritten);
     VByte.writeInt(scratch, Ints.checkedCast(headerOut.size() + valuesOut.size()));
     scratch.flip();
diff --git a/processing/src/test/java/org/apache/druid/guice/StartupInjectorBuilderTest.java b/processing/src/test/java/org/apache/druid/guice/StartupInjectorBuilderTest.java
index bcf85742c2ac..28a8085edcde 100644
--- a/processing/src/test/java/org/apache/druid/guice/StartupInjectorBuilderTest.java
+++ b/processing/src/test/java/org/apache/druid/guice/StartupInjectorBuilderTest.java
@@ -20,7 +20,6 @@
 package org.apache.druid.guice;
 
 import com.google.inject.Injector;
-import org.apache.druid.common.config.NullValueHandlingConfig;
 import org.apache.druid.error.ExceptionMatcher;
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.StringUtils;
@@ -147,7 +146,7 @@ public void testExtensionsOption()
   public void testValidator()
   {
     final Properties propsDefaultValueMode = new Properties();
-    propsDefaultValueMode.put(NullValueHandlingConfig.NULL_HANDLING_CONFIG_STRING, "true");
+    propsDefaultValueMode.put(StartupInjectorBuilder.NULL_HANDLING_CONFIG_STRING, "true");
 
     Throwable t = Assert.assertThrows(
         ISE.class,
@@ -164,7 +163,7 @@ public void testValidator()
     );
 
     final Properties propsNo3vl = new Properties();
-    propsNo3vl.put(NullValueHandlingConfig.THREE_VALUE_LOGIC_CONFIG_STRING, "false");
+    propsNo3vl.put(StartupInjectorBuilder.THREE_VALUE_LOGIC_CONFIG_STRING, "false");
     t = Assert.assertThrows(
         ISE.class,
         () -> new StartupInjectorBuilder().withExtensions()
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/any/NumericAnyVectorAggregatorTest.java b/processing/src/test/java/org/apache/druid/query/aggregation/any/NumericAnyVectorAggregatorTest.java
index 76b670aac1a0..e9c60d35a51c 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/any/NumericAnyVectorAggregatorTest.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/any/NumericAnyVectorAggregatorTest.java
@@ -19,7 +19,7 @@
 
 package org.apache.druid.query.aggregation.any;
 
-import org.apache.druid.common.config.NullHandling;
+import org.apache.druid.segment.column.TypeStrategies;
 import org.apache.druid.segment.vector.VectorValueSelector;
 import org.apache.druid.testing.InitializedNullHandlingTest;
 import org.junit.Assert;
@@ -95,7 +95,7 @@ public void initShouldSetDoubleAfterPositionToZero()
     target.init(buf, POSITION);
     Assert.assertEquals(0, buf.get(POSITION) & BYTE_FLAG_FOUND_MASK);
     Assert.assertEquals(
-        NullHandling.IS_NULL_BYTE,
+        TypeStrategies.IS_NULL_BYTE,
         buf.get(POSITION)
     );
   }
@@ -104,14 +104,14 @@ public void initShouldSetDoubleAfterPositionToZero()
   public void aggregateNotFoundAndHasNullsShouldPutNull()
   {
     target.aggregate(buf, POSITION, 0, 3);
-    Assert.assertEquals(BYTE_FLAG_FOUND_MASK | NullHandling.IS_NULL_BYTE, buf.get(POSITION));
+    Assert.assertEquals(BYTE_FLAG_FOUND_MASK | TypeStrategies.IS_NULL_BYTE, buf.get(POSITION));
   }
 
   @Test
   public void aggregateNotFoundAndHasNullsOutsideRangeShouldPutValue()
   {
     target.aggregate(buf, POSITION, 0, 1);
-    Assert.assertEquals(BYTE_FLAG_FOUND_MASK | NullHandling.IS_NOT_NULL_BYTE, buf.get(POSITION));
+    Assert.assertEquals(BYTE_FLAG_FOUND_MASK | TypeStrategies.IS_NOT_NULL_BYTE, buf.get(POSITION));
   }
 
   @Test
@@ -119,7 +119,7 @@ public void aggregateNotFoundAndNoNullsShouldPutValue()
   {
     Mockito.doReturn(null).when(selector).getNullVector();
     target.aggregate(buf, POSITION, 0, 3);
-    Assert.assertEquals(BYTE_FLAG_FOUND_MASK | NullHandling.IS_NOT_NULL_BYTE, buf.get(POSITION));
+    Assert.assertEquals(BYTE_FLAG_FOUND_MASK | TypeStrategies.IS_NOT_NULL_BYTE, buf.get(POSITION));
   }
 
   @Test
@@ -141,8 +141,8 @@ public void aggregateBatchNoRowsShouldAggregateAllRows()
     for (int i = 0; i < positions.length; i++) {
       int position = positions[i] + positionOffset;
       Assert.assertEquals(
-          BYTE_FLAG_FOUND_MASK | NullHandling.IS_NOT_NULL_BYTE,
-          buf.get(position) & (byte) (BYTE_FLAG_FOUND_MASK | NullHandling.IS_NOT_NULL_BYTE)
+          BYTE_FLAG_FOUND_MASK | TypeStrategies.IS_NOT_NULL_BYTE,
+          buf.get(position) & (byte) (BYTE_FLAG_FOUND_MASK | TypeStrategies.IS_NOT_NULL_BYTE)
       );
       Assert.assertEquals(i, buf.getLong(position + 1));
     }
@@ -160,8 +160,8 @@ public void aggregateBatchWithRowsShouldAggregateAllRows()
     for (int i = 0; i < positions.length; i++) {
       int position = positions[i] + positionOffset;
       Assert.assertEquals(
-          BYTE_FLAG_FOUND_MASK | NullHandling.IS_NOT_NULL_BYTE,
-          buf.get(position) & (byte) (BYTE_FLAG_FOUND_MASK | NullHandling.IS_NOT_NULL_BYTE)
+          BYTE_FLAG_FOUND_MASK | TypeStrategies.IS_NOT_NULL_BYTE,
+          buf.get(position) & (byte) (BYTE_FLAG_FOUND_MASK | TypeStrategies.IS_NOT_NULL_BYTE)
       );
       Assert.assertEquals(rows[i], buf.getLong(position + 1));
     }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/BaseCalciteQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/BaseCalciteQueryTest.java
index 61dc44a6771f..52605f04dce7 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/BaseCalciteQueryTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/BaseCalciteQueryTest.java
@@ -28,7 +28,6 @@
 import com.google.common.collect.ImmutableMap;
 import com.google.common.io.ByteStreams;
 import org.apache.commons.text.StringEscapeUtils;
-import org.apache.druid.common.config.NullHandling;
 import org.apache.druid.error.DruidException;
 import org.apache.druid.error.DruidException.Category;
 import org.apache.druid.error.DruidException.Persona;
@@ -1017,9 +1016,6 @@ private static Object[] homogenizeArray(Object array)
     }
   }
 
-  /**
-   * Validates the results with slight loosening in case {@link NullHandling} is not sql compatible.
-   */
   public void assertResultsValid(final ResultMatchMode matchMode, final List<Object[]> expected, final QueryResults queryResults)
   {
     final List<Object[]> results = queryResults.results;

From 2bb9d3da53faa2530cb109d8c84c05704f20e3f8 Mon Sep 17 00:00:00 2001
From: Katya Macedo <38017980+ektravel@users.noreply.github.com>
Date: Mon, 10 Mar 2025 19:22:39 -0500
Subject: [PATCH 26/99] Docs: Add SQL query example (#17593)

* Docs: Add query example

* Update after review

* Update query

* Update docs/api-reference/sql-api.md

---------

Co-authored-by: Victoria Lim <vtlim@users.noreply.github.com>
---
 docs/api-reference/sql-api.md | 21 +++++++++------------
 docs/querying/sql.md          |  9 ++++-----
 2 files changed, 13 insertions(+), 17 deletions(-)

diff --git a/docs/api-reference/sql-api.md b/docs/api-reference/sql-api.md
index f6a624c8ce23..2b25bdd02f0b 100644
--- a/docs/api-reference/sql-api.md
+++ b/docs/api-reference/sql-api.md
@@ -85,20 +85,18 @@ The request body takes the following properties:
 
 * `context`: JSON object containing optional [SQL query context parameters](../querying/sql-query-context.md), such as to set the query ID, time zone, and whether to use an approximation algorithm for distinct count.
 
-* `parameters`: List of query parameters for parameterized queries. Each parameter in the array should be a JSON object containing the parameter's SQL data type and parameter value. For a list of supported SQL types, see [Data types](../querying/sql-data-types.md).
+* `parameters`: List of query parameters for parameterized queries. Each parameter in the array should be a JSON object containing the parameter's SQL data type and parameter value. For more information on using dynamic parameters, see [Dynamic parameters](../querying/sql.md#dynamic-parameters). For a list of supported SQL types, see [Data types](../querying/sql-data-types.md).
 
     For example:
+
     ```json
-    "parameters": [
-        {
-            "type": "VARCHAR",
-            "value": "bar"
-        },
-        {
-            "type": "ARRAY",
-            "value": [-25.7, null, 36.85]
-        }
-    ]
+    {
+        "query": "SELECT \"arrayDouble\", \"stringColumn\" FROM \"array_example\" WHERE ARRAY_CONTAINS(\"arrayDouble\", ?) AND \"stringColumn\" = ?",
+        "parameters": [
+            {"type": "ARRAY", "value": [999.0, null, 5.5]},
+            {"type": "VARCHAR", "value": "bar"}
+            ]
+    }
     ```
 
 #### Responses
@@ -155,7 +153,6 @@ If you detect a truncated response, treat it as an error.
 
 ---
 
-
 #### Sample request
 
 The following example retrieves all rows in the `wikipedia` datasource where the `user` is `BlueMoon2662`. The query is assigned the ID `request01` using the `sqlQueryId` context parameter. The optional properties `header`, `typesHeader`, and `sqlTypesHeader` are set to `true` to include type information to the response.
diff --git a/docs/querying/sql.md b/docs/querying/sql.md
index 6a47ac3a4c0d..881711f05771 100644
--- a/docs/querying/sql.md
+++ b/docs/querying/sql.md
@@ -403,7 +403,7 @@ The following example query uses the [ARRAY_CONTAINS](./sql-functions.md#array_c
 
 ```sql
 {
-   "query": "SELECT doubleArrayColumn from druid.table where ARRAY_CONTAINS(?, doubleArrayColumn)",
+   "query": "SELECT doubleArrayColumn from druid.table where ARRAY_CONTAINS(doubleArrayColumn, ?)",
    "parameters": [
       {
         "type": "ARRAY",
@@ -428,17 +428,16 @@ SELECT * FROM druid.foo WHERE dim1 like CONCAT('%', CAST (? AS VARCHAR), '%')
 Dynamic parameters can even replace arrays, reducing the parsing time. Refer to the parameters in the [API request body](../api-reference/sql-api.md#request-body) for usage.
 
 ```sql
-SELECT arrayColumn from druid.table where ARRAY_CONTAINS(?, arrayColumn)
+SELECT arrayColumn from druid.table where ARRAY_CONTAINS(arrayColumn, ?)
 ```
 
-With this, an IN filter being supplied with a lot of values, can be replaced by a dynamic parameter passed inside [SCALAR_IN_ARRAY](sql-functions.md#scalar_in_array)
+You can replace an IN filter with many values by dynamically passing a parameter into [SCALAR_IN_ARRAY](sql-functions.md#scalar_in_array).
+For example Java queries, see [Dynamic parameters](../api-reference/sql-jdbc.md#dynamic-parameters).
 
 ```sql
 SELECT count(city) from druid.table where SCALAR_IN_ARRAY(city, ?)
 ```
 
-sample java code using dynamic parameters is provided [here](../api-reference/sql-jdbc.md#dynamic-parameters).
-
 ## Reserved keywords
 
 Druid SQL reserves certain keywords which are used in its query language. Apache Druid inherits all of the reserved keywords from [Apache Calcite](https://calcite.apache.org/docs/reference.html#keywords). In addition to these, the following reserved keywords are unique to Apache Druid:

From 45424ba56288a476493467206f736a7a2839c3cb Mon Sep 17 00:00:00 2001
From: Kashif Faraz <kashif.faraz@gmail.com>
Date: Wed, 12 Mar 2025 11:36:59 +0530
Subject: [PATCH 27/99] More logging cleanup on Overlord (#17780)

---
 .../actions/SegmentAllocationQueue.java       | 30 +++++++++----------
 .../druid/indexing/overlord/TaskLockbox.java  |  6 ++--
 .../druid/indexing/overlord/TaskQueue.java    |  6 ++--
 .../supervisor/SeekableStreamSupervisor.java  |  2 +-
 .../autoscaler/LagBasedAutoScaler.java        |  6 ++--
 .../org/apache/druid/query/DruidMetrics.java  | 16 +++++-----
 .../java/org/apache/druid/query/Druids.java   |  5 ----
 .../IndexerSQLMetadataStorageCoordinator.java |  3 +-
 8 files changed, 35 insertions(+), 39 deletions(-)

diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/SegmentAllocationQueue.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/SegmentAllocationQueue.java
index 3c86e8e5637d..724364c27413 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/SegmentAllocationQueue.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/SegmentAllocationQueue.java
@@ -341,7 +341,7 @@ private boolean processBatch(AllocateRequestBatch requestBatch)
     }
 
     log.debug(
-        "Processing [%d] requests for batch [%s], queue time [%s].",
+        "Processing [%d] requests for batch[%s], queue time[%s].",
         requestBatch.size(), requestKey, requestBatch.getQueueTime()
     );
 
@@ -355,21 +355,21 @@ private boolean processBatch(AllocateRequestBatch requestBatch)
 
     emitBatchMetric("task/action/batch/attempts", 1L, requestKey);
     emitBatchMetric("task/action/batch/runTime", (System.currentTimeMillis() - startTimeMillis), requestKey);
-    log.info("Successfully processed [%d / %d] requests in batch [%s].", successCount, batchSize, requestKey);
+    log.debug("Successfully processed [%d / %d] requests in batch[%s].", successCount, batchSize, requestKey);
 
     if (requestBatch.isEmpty()) {
       return true;
     }
 
     // Requeue the batch only if used segments have changed
-    log.debug("There are [%d] failed requests in batch [%s].", requestBatch.size(), requestKey);
+    log.debug("There are [%d] failed requests in batch[%s].", requestBatch.size(), requestKey);
     final Set<DataSegment> updatedUsedSegments = retrieveUsedSegments(requestKey);
 
     if (updatedUsedSegments.equals(usedSegments)) {
       log.warn(
-          "Completing [%d] failed requests in batch [%s] with null value as there"
+          "Completing [%d] failed requests in batch[%s] with null value as there"
           + " are conflicting segments. Cannot retry allocation until the set of"
-          + " used segments overlapping the allocation interval [%s] changes.",
+          + " used segments overlapping the allocation interval[%s] changes.",
           size(), requestKey, requestKey.preferredAllocationInterval
       );
 
@@ -452,9 +452,9 @@ private int allocateSegmentsForBatch(AllocateRequestBatch requestBatch, Set<Data
     }
 
     if (!requestsWithPartialOverlap.isEmpty()) {
-      log.info(
-          "Found [%d] requests in batch [%s] with row intervals that partially overlap existing segments."
-          + " These cannot be processed until the set of used segments changes. Example request: [%s]",
+      log.warn(
+          "Found [%d] requests in batch[%s] with row intervals that partially overlap existing segments."
+          + " These cannot be processed until the set of used segments changes. Example request[%s]",
           requestsWithPartialOverlap.size(), requestBatch.key, requestsWithPartialOverlap.get(0)
       );
     }
@@ -485,7 +485,7 @@ private int allocateSegmentsForInterval(
 
     final AllocateRequestKey requestKey = requestBatch.key;
     log.debug(
-        "Trying allocation for [%d] requests, interval [%s] in batch [%s]",
+        "Trying allocation for [%d] requests, interval[%s] in batch[%s]",
         requests.size(), tryInterval, requestKey
     );
 
@@ -531,14 +531,14 @@ private void emitTaskMetric(String metric, long value, SegmentAllocateRequest re
   {
     final ServiceMetricEvent.Builder metricBuilder = ServiceMetricEvent.builder();
     IndexTaskUtils.setTaskDimensions(metricBuilder, request.getTask());
-    metricBuilder.setDimension("taskActionType", SegmentAllocateAction.TYPE);
+    metricBuilder.setDimension(DruidMetrics.TASK_ACTION_TYPE, SegmentAllocateAction.TYPE);
     emitter.emit(metricBuilder.setMetric(metric, value));
   }
 
   private void emitBatchMetric(String metric, long value, AllocateRequestKey key)
   {
     final ServiceMetricEvent.Builder metricBuilder = ServiceMetricEvent.builder();
-    metricBuilder.setDimension("taskActionType", SegmentAllocateAction.TYPE);
+    metricBuilder.setDimension(DruidMetrics.TASK_ACTION_TYPE, SegmentAllocateAction.TYPE);
     metricBuilder.setDimension(DruidMetrics.DATASOURCE, key.dataSource);
     metricBuilder.setDimension(DruidMetrics.INTERVAL, key.preferredAllocationInterval.toString());
     emitter.emit(metricBuilder.setMetric(metric, value));
@@ -651,15 +651,15 @@ void handleResult(SegmentAllocateResult result, SegmentAllocateRequest request)
         emitTaskMetric("task/action/success/count", 1L, request);
         requestToFuture.remove(request).complete(result.getSegmentId());
       } else if (request.canRetry()) {
-        log.info(
-            "Allocation failed on attempt [%d] due to error [%s]. Can still retry action [%s].",
+        log.debug(
+            "Allocation failed on attempt [%d] due to error[%s]. Can still retry action[%s].",
             request.getAttempts(), result.getErrorMessage(), request.getAction()
         );
       } else {
         emitTaskMetric("task/action/failed/count", 1L, request);
         log.error(
-            "Exhausted max attempts [%d] for allocation with latest error [%s]."
-            + " Completing action [%s] with a null value.",
+            "Exhausted max attempts[%d] for allocation with latest error[%s]."
+            + " Completing action[%s] with a null value.",
             request.getAttempts(), result.getErrorMessage(), request.getAction()
         );
         requestToFuture.remove(request).complete(null);
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/TaskLockbox.java b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/TaskLockbox.java
index 1e1a43994925..d46cc6071d04 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/TaskLockbox.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/TaskLockbox.java
@@ -474,7 +474,7 @@ public List<SegmentAllocateResult> allocateSegments(
       boolean reduceMetadataIO
   )
   {
-    log.info("Allocating [%d] segments for datasource [%s], interval [%s]", requests.size(), dataSource, interval);
+    log.debug("Allocating [%d] segments for datasource[%s], interval[%s]", requests.size(), dataSource, interval);
     final boolean isTimeChunkLock = lockGranularity == LockGranularity.TIME_CHUNK;
 
     final AllocationHolderList holderList = new AllocationHolderList(requests, interval);
@@ -1132,11 +1132,11 @@ private void unlock(final Task task, final Interval interval, @Nullable Integer
 
         if (match) {
           // Remove task from live list
-          log.info("Removing task[%s] from TaskLock[%s]", task.getId(), taskLock);
+          log.debug("Removing task[%s] from TaskLock[%s]", task.getId(), taskLock);
           final boolean removed = taskLockPosse.removeTask(task);
 
           if (taskLockPosse.isTasksEmpty()) {
-            log.info("TaskLock[%s] is now empty.", taskLock);
+            log.debug("TaskLock[%s] is now empty.", taskLock);
             possesHolder.remove(taskLockPosse);
           }
           if (possesHolder.isEmpty()) {
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/TaskQueue.java b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/TaskQueue.java
index 89bd441328a5..3bbafb749017 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/TaskQueue.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/TaskQueue.java
@@ -440,7 +440,7 @@ private void manageInternalCritical(
             continue;
           }
           if (taskIsReady) {
-            log.info("Asking taskRunner to run: %s", task.getId());
+            log.info("Asking taskRunner to run task[%s]", task.getId());
             runnerTaskFuture = taskRunner.run(task);
           } else {
             // Task.isReady() can internally lock intervals or segments.
@@ -469,7 +469,7 @@ private void manageInternalPostCritical(
     // Kill tasks that shouldn't be running
     final Set<String> tasksToKill = Sets.difference(runnerTaskFutures.keySet(), knownTaskIds);
     if (!tasksToKill.isEmpty()) {
-      log.info("Asking taskRunner to clean up %,d tasks.", tasksToKill.size());
+      log.info("Asking taskRunner to clean up [%,d] tasks.", tasksToKill.size());
 
       // On large installations running several thousands of tasks,
       // concatenating the list of known task ids can be compupationally expensive.
@@ -483,7 +483,7 @@ private void manageInternalPostCritical(
           taskRunner.shutdown(taskId, reason);
         }
         catch (Exception e) {
-          log.warn(e, "TaskRunner failed to clean up task: %s", taskId);
+          log.warn(e, "TaskRunner failed to clean up task[%s].", taskId);
         }
       }
     }
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java b/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java
index 47781826265a..442dcc35f4c5 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java
@@ -3222,7 +3222,7 @@ private void checkTaskDuration() throws ExecutionException, InterruptedException
 
     final boolean stopTasksEarly;
     if (earlyStopTime != null && !earlyStopTime.isAfterNow()) {
-      log.info("Early stop requested, signalling tasks to complete.");
+      log.info("Early stop requested for supervisor[%s], signalling tasks to complete.", supervisorId);
       earlyStopTime = null;
       stopTasksEarly = true;
     } else {
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/autoscaler/LagBasedAutoScaler.java b/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/autoscaler/LagBasedAutoScaler.java
index 648d8a655e92..2786860ecad8 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/autoscaler/LagBasedAutoScaler.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/autoscaler/LagBasedAutoScaler.java
@@ -178,7 +178,7 @@ private Runnable computeAndCollectLag()
           }
           log.debug("Current lags for dataSource[%s] are [%s].", dataSource, lagMetricsQueue);
         } else {
-          log.warn("[%s] supervisor is suspended, skipping lag collection", dataSource);
+          log.debug("Supervisor[%s] is suspended, skipping lag collection", dataSource);
         }
       }
       catch (Exception e) {
@@ -237,7 +237,7 @@ private int computeDesiredTaskCount(List<Long> lags)
 
       int actualTaskCountMax = Math.min(lagBasedAutoScalerConfig.getTaskCountMax(), partitionCount);
       if (currentActiveTaskCount == actualTaskCountMax) {
-        log.warn("CurrentActiveTaskCount reached task count Max limit, skipping scale out action for dataSource [%s].",
+        log.debug("CurrentActiveTaskCount reached task count Max limit, skipping scale out action for dataSource [%s].",
             dataSource
         );
         emitter.emit(metricBuilder
@@ -258,7 +258,7 @@ private int computeDesiredTaskCount(List<Long> lags)
       int taskCount = currentActiveTaskCount - lagBasedAutoScalerConfig.getScaleInStep();
       int actualTaskCountMin = Math.min(lagBasedAutoScalerConfig.getTaskCountMin(), partitionCount);
       if (currentActiveTaskCount == actualTaskCountMin) {
-        log.warn("CurrentActiveTaskCount reached task count Min limit, skipping scale in action for dataSource [%s].",
+        log.debug("CurrentActiveTaskCount reached task count Min limit, skipping scale in action for dataSource[%s].",
             dataSource
         );
         emitter.emit(metricBuilder
diff --git a/processing/src/main/java/org/apache/druid/query/DruidMetrics.java b/processing/src/main/java/org/apache/druid/query/DruidMetrics.java
index 1f478809333b..6551fc5c6004 100644
--- a/processing/src/main/java/org/apache/druid/query/DruidMetrics.java
+++ b/processing/src/main/java/org/apache/druid/query/DruidMetrics.java
@@ -25,27 +25,29 @@
 import java.util.List;
 
 /**
+ * Contains dimension names used while emitting metrics.
  */
 public class DruidMetrics
 {
+  // Query dimensions
   public static final String DATASOURCE = "dataSource";
   public static final String TYPE = "type";
   public static final String INTERVAL = "interval";
   public static final String ID = "id";
   public static final String SUBQUERY_ID = "subQueryId";
-  public static final String TASK_ID = "taskId";
-  public static final String GROUP_ID = "groupId";
   public static final String STATUS = "status";
-  public static final String TASK_INGESTION_MODE = "taskIngestionMode";
-
-  public static final String PARTITIONING_TYPE = "partitioningType";
 
-  // task metrics
+  // Task dimensions
+  public static final String TASK_ID = "taskId";
+  public static final String GROUP_ID = "groupId";
   public static final String TASK_TYPE = "taskType";
   public static final String TASK_STATUS = "taskStatus";
 
+  // Ingestion dimensions
+  public static final String PARTITIONING_TYPE = "partitioningType";
+  public static final String TASK_INGESTION_MODE = "taskIngestionMode";
+  public static final String TASK_ACTION_TYPE = "taskActionType";
   public static final String STREAM = "stream";
-
   public static final String PARTITION = "partition";
 
   public static final String TAGS = "tags";
diff --git a/processing/src/main/java/org/apache/druid/query/Druids.java b/processing/src/main/java/org/apache/druid/query/Druids.java
index 90feacc004cf..5ce472c9b31e 100644
--- a/processing/src/main/java/org/apache/druid/query/Druids.java
+++ b/processing/src/main/java/org/apache/druid/query/Druids.java
@@ -1065,9 +1065,4 @@ public static DataSourceMetadataQueryBuilder newDataSourceMetadataQueryBuilder()
   {
     return new DataSourceMetadataQueryBuilder();
   }
-
-  public static FilteredDataSource filteredDataSource(DataSource base, DimFilter filter)
-  {
-    return FilteredDataSource.create(base, filter);
-  }
 }
diff --git a/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java b/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java
index 85667d176dd8..fcdd31d0fa6a 100644
--- a/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java
+++ b/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java
@@ -1261,7 +1261,7 @@ private Map<SegmentCreateRequest, PendingSegmentRecord> createNewSegments(
         if (createdSegment != null) {
           pendingSegments.add(createdSegment.getId());
           uniqueRequestToSegment.put(uniqueRequest, createdSegment);
-          log.info("Created new segment[%s]", createdSegment.getId());
+          log.debug("Created new segment[%s]", createdSegment.getId());
         }
       }
 
@@ -1270,7 +1270,6 @@ private Map<SegmentCreateRequest, PendingSegmentRecord> createNewSegments(
       }
     }
 
-    log.info("Created [%d] new segments for [%d] allocate requests.", uniqueRequestToSegment.size(), requests.size());
     return createdSegments;
   }
 

From c4a4f4d0433fc614649703494ca36cd03605cc94 Mon Sep 17 00:00:00 2001
From: Kashif Faraz <kashif.faraz@gmail.com>
Date: Thu, 13 Mar 2025 14:30:38 +0530
Subject: [PATCH 28/99] Remove maven.twttr repo from pom (#17797)

remove usage of dependency:go-offline from build scripts - as it tries to download excluded artifacts

---------

Co-authored-by: Zoltan Haindrich <kirk@rxd.hu>
---
 .github/workflows/cron-job-its.yml             |  2 +-
 integration-tests/script/setup_druid_on_k8s.sh |  2 +-
 it.sh                                          |  2 +-
 pom.xml                                        | 10 ----------
 4 files changed, 3 insertions(+), 13 deletions(-)

diff --git a/.github/workflows/cron-job-its.yml b/.github/workflows/cron-job-its.yml
index 3eb921bf1ae2..ddf26c019ee5 100644
--- a/.github/workflows/cron-job-its.yml
+++ b/.github/workflows/cron-job-its.yml
@@ -127,7 +127,7 @@ jobs:
           cache: maven
 
       - name: maven build # needed to rebuild incase of maven snapshot resolution fails
-        run: mvn clean install dependency:go-offline -P dist -P skip-static-checks,skip-tests -Dmaven.javadoc.skip=true -Dcyclonedx.skip=true -Dweb.console.skip=true
+        run: mvn clean install -P dist -P skip-static-checks,skip-tests -Dmaven.javadoc.skip=true -Dcyclonedx.skip=true -Dweb.console.skip=true
 
       - name: security vulnerabilities check
         run: |
diff --git a/integration-tests/script/setup_druid_on_k8s.sh b/integration-tests/script/setup_druid_on_k8s.sh
index 960eedfe5fcc..3a860f3e72da 100755
--- a/integration-tests/script/setup_druid_on_k8s.sh
+++ b/integration-tests/script/setup_druid_on_k8s.sh
@@ -26,7 +26,7 @@ cp -r client_tls docker/client_tls
 cd ..
 
 # Build Docker images for pods
-mvn -B -ff -q dependency:go-offline \
+mvn -B -ff -q \
       install \
       -Pdist,bundle-contrib-exts \
       -Pskip-static-checks,skip-tests \
diff --git a/it.sh b/it.sh
index cf9e02e2b2cc..53eddd087b07 100755
--- a/it.sh
+++ b/it.sh
@@ -229,7 +229,7 @@ case $CMD in
     usage
     ;;
   "ci" )
-    mvn -q clean install dependency:go-offline -P dist $MAVEN_IGNORE -T1C
+    mvn -q clean install -P dist $MAVEN_IGNORE -T1C
     ;;
   "build" )
     mvn -B clean install -P dist $MAVEN_IGNORE -T1.0C $*
diff --git a/pom.xml b/pom.xml
index 35261750755b..9b53b1b644dc 100644
--- a/pom.xml
+++ b/pom.xml
@@ -293,16 +293,6 @@
                <enabled>false</enabled>
             </snapshots>
         </repository>
-
-        <!--
-        maven-dependency-plugin:3.1.2 seems to have updated HTTP repository access behavior.
-        We get the following error "Blocked mirror for repositories: [twitter (http://maven.twttr.com, default, releases+snapshots)]"
-        The suggested action step is to add the mirror: https://maven.apache.org/docs/3.8.1/release-notes.html#how-to-fix-when-i-get-a-http-repository-blocked
-        -->
-        <repository>
-            <id>twitter</id>
-            <url>https://maven.twttr.com</url>
-        </repository>
     </repositories>
 
     <pluginRepositories>

From 980c492898e9069717c0533afbbc55ef4282b12b Mon Sep 17 00:00:00 2001
From: Zoltan Haindrich <kirk@rxd.hu>
Date: Thu, 13 Mar 2025 11:39:49 +0100
Subject: [PATCH 29/99] fix bug (#17791)

---
 .../org/apache/druid/sql/calcite/util/FakeIndexTaskUtil.java    | 2 +-
 sql/src/test/quidem/sampledataset/rollup-index.json             | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/FakeIndexTaskUtil.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/FakeIndexTaskUtil.java
index 6af4aa2ea34a..ad8f28b16ba8 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/util/FakeIndexTaskUtil.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/FakeIndexTaskUtil.java
@@ -75,7 +75,7 @@ private static InputSource relativizeLocalInputSource(InputSource inputSource, F
     if (localInputSource.getBaseDir().isAbsolute()) {
       return inputSource;
     }
-    File newBaseDir = localInputSource.getBaseDir().toPath().resolve(projectRoot.toPath()).toFile();
+    File newBaseDir = projectRoot.toPath().resolve(localInputSource.getBaseDir().toPath()).toFile();
     return new LocalInputSource(
         newBaseDir,
         localInputSource.getFilter(),
diff --git a/sql/src/test/quidem/sampledataset/rollup-index.json b/sql/src/test/quidem/sampledataset/rollup-index.json
index a978c2a76d27..e59580d67b82 100644
--- a/sql/src/test/quidem/sampledataset/rollup-index.json
+++ b/sql/src/test/quidem/sampledataset/rollup-index.json
@@ -30,7 +30,7 @@
       "type" : "index_parallel",
       "inputSource" : {
         "type" : "local",
-        "baseDir" : "quickstart/tutorial",
+        "baseDir" : "examples/quickstart/tutorial",
         "filter" : "rollup-data.json"
       },
       "inputFormat" : {

From e3eeef4aaa8c2d9d96ff49d89f8232da1996d13e Mon Sep 17 00:00:00 2001
From: Gian Merlino <gianmerlino@gmail.com>
Date: Thu, 13 Mar 2025 11:53:34 -0700
Subject: [PATCH 30/99] Log query stack traces for DEVELOPER and OPERATOR
 personas. (#17790)

Currently, query stack traces are logged only when "debug: true" is set
in the query context. This patch additionally logs stack traces targeted
at the DEVELOPER or OPERATOR personas, because for these personas, stack
traces are useful more often than not.

We continue to omit stack traces by default for USER and ADMIN, because
these personas are meant to interact with the API, not with code or logs.
Skipping stack traces minimizes clutter in the logs.
---
 .../apache/druid/server/QueryLifecycle.java   | 23 ++++++++++++++++++-
 .../apache/druid/sql/http/SqlResource.java    |  3 ++-
 2 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/server/src/main/java/org/apache/druid/server/QueryLifecycle.java b/server/src/main/java/org/apache/druid/server/QueryLifecycle.java
index 6ffc8aff0bba..f5c167360c6a 100644
--- a/server/src/main/java/org/apache/druid/server/QueryLifecycle.java
+++ b/server/src/main/java/org/apache/druid/server/QueryLifecycle.java
@@ -423,7 +423,7 @@ public void emitLogsAndMetrics(
 
       if (e != null) {
         statsMap.put("exception", e.toString());
-        if (baseQuery.context().isDebug() || e.getMessage() == null) {
+        if (shouldLogStackTrace(e, baseQuery.context())) {
           log.warn(e, "Exception while processing queryId [%s]", baseQuery.getId());
         } else {
           log.noStackTrace().warn(e, "Exception while processing queryId [%s]", baseQuery.getId());
@@ -518,4 +518,25 @@ enum State
     DONE
   }
 
+  /**
+   * Returns whether stack traces should be logged for a particular exception thrown with a particular query context.
+   * Stack traces are logged if {@link QueryContext#isDebug()}, or if the {@link DruidException.Persona} is
+   * {@link DruidException.Persona#DEVELOPER} or {@link DruidException.Persona#OPERATOR}. The idea is that other
+   * personas are meant to interact with the API, not with code or logs, so logging stack traces by default adds
+   * clutter that is not very helpful.
+   *
+   * @param e            exception
+   * @param queryContext query context
+   */
+  public static boolean shouldLogStackTrace(final Throwable e, final QueryContext queryContext)
+  {
+    if (queryContext.isDebug() || e.getMessage() == null) {
+      return true;
+    } else if (e instanceof DruidException) {
+      final DruidException.Persona persona = ((DruidException) e).getTargetPersona();
+      return persona == DruidException.Persona.OPERATOR || persona == DruidException.Persona.DEVELOPER;
+    } else {
+      return false;
+    }
+  }
 }
diff --git a/sql/src/main/java/org/apache/druid/sql/http/SqlResource.java b/sql/src/main/java/org/apache/druid/sql/http/SqlResource.java
index b53b49f0fcaa..c966b4ec8bd2 100644
--- a/sql/src/main/java/org/apache/druid/sql/http/SqlResource.java
+++ b/sql/src/main/java/org/apache/druid/sql/http/SqlResource.java
@@ -28,6 +28,7 @@
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.java.util.common.logger.Logger;
 import org.apache.druid.server.DruidNode;
+import org.apache.druid.server.QueryLifecycle;
 import org.apache.druid.server.QueryResource;
 import org.apache.druid.server.QueryResponse;
 import org.apache.druid.server.QueryResultPusher;
@@ -304,7 +305,7 @@ public void recordSuccess(long numBytes)
         @Override
         public void recordFailure(Exception e)
         {
-          if (sqlQuery.queryContext().isDebug()) {
+          if (QueryLifecycle.shouldLogStackTrace(e, sqlQuery.queryContext())) {
             log.warn(e, "Exception while processing sqlQueryId[%s]", sqlQueryId);
           } else {
             log.noStackTrace().warn(e, "Exception while processing sqlQueryId[%s]", sqlQueryId);

From e417008e88d8523521be1898f268db1d32a31f06 Mon Sep 17 00:00:00 2001
From: Kashif Faraz <kashif.faraz@gmail.com>
Date: Fri, 14 Mar 2025 09:45:32 +0530
Subject: [PATCH 31/99] Set useMaxMemoryEstimates=false for MSQ tasks (#17792)

---
 .../processor/SegmentGeneratorFrameProcessorFactory.java     | 2 +-
 .../java/org/apache/druid/indexing/common/task/Tasks.java    | 5 +++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/indexing/processor/SegmentGeneratorFrameProcessorFactory.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/indexing/processor/SegmentGeneratorFrameProcessorFactory.java
index 3fa5654c2a55..fed66e889555 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/indexing/processor/SegmentGeneratorFrameProcessorFactory.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/indexing/processor/SegmentGeneratorFrameProcessorFactory.java
@@ -194,7 +194,7 @@ public Pair<Integer, ReadableInput> apply(ReadableInput readableInput)
                   frameContext.indexMerger(),
                   meters,
                   parseExceptionHandler,
-                  true,
+                  false,
                   // MSQ doesn't support CentralizedDatasourceSchema feature as of now.
                   CentralizedDatasourceSchemaConfig.create(false)
               );
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/Tasks.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/Tasks.java
index a8f268a67f13..5a1d7f1cac45 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/Tasks.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/Tasks.java
@@ -57,9 +57,10 @@ public class Tasks
    * on-heap memory usage while indexing. Refer to OnHeapIncrementalIndex for
    * more details.
    * <p>
-   * The value of this flag is true by default which corresponds to the old method
-   * of estimation.
+   * @deprecated This flag will be removed in future Druid releases, and the new
+   * method of memory estimation will be used in all cases.
    */
+  @Deprecated
   public static final String USE_MAX_MEMORY_ESTIMATES = "useMaxMemoryEstimates";
 
   /**

From 5096d5b4b9cea75d15a630933ba1660c001ecad6 Mon Sep 17 00:00:00 2001
From: Vadim Ogievetsky <vadim@ogievetsky.com>
Date: Fri, 14 Mar 2025 09:25:34 -0700
Subject: [PATCH 32/99] Web console: fix go to task selecting correct task type
 (#17788)

* fix go to task selecting correct task type

* support autocompact also

* support scheduled_batch, refactor

* one more state and update tests
---
 .../supervisors-view.spec.tsx.snap            |   4 +-
 .../supervisors-view/supervisors-view.tsx     | 105 +++++++++++-------
 2 files changed, 68 insertions(+), 41 deletions(-)

diff --git a/web-console/src/views/supervisors-view/__snapshots__/supervisors-view.spec.tsx.snap b/web-console/src/views/supervisors-view/__snapshots__/supervisors-view.spec.tsx.snap
index 273fa44d9db5..a3fdd9212785 100644
--- a/web-console/src/views/supervisors-view/__snapshots__/supervisors-view.spec.tsx.snap
+++ b/web-console/src/views/supervisors-view/__snapshots__/supervisors-view.spec.tsx.snap
@@ -172,7 +172,7 @@ exports[`SupervisorsView matches snapshot 1`] = `
           "Header": "Type",
           "accessor": "type",
           "show": true,
-          "width": 80,
+          "width": 120,
         },
         {
           "Cell": [Function],
@@ -188,7 +188,7 @@ exports[`SupervisorsView matches snapshot 1`] = `
           "accessor": "detailed_state",
           "id": "detailed_state",
           "show": true,
-          "width": 150,
+          "width": 170,
         },
         {
           "Cell": [Function],
diff --git a/web-console/src/views/supervisors-view/supervisors-view.tsx b/web-console/src/views/supervisors-view/supervisors-view.tsx
index 89ad8ebfcb99..a81fda3d7f00 100644
--- a/web-console/src/views/supervisors-view/supervisors-view.tsx
+++ b/web-console/src/views/supervisors-view/supervisors-view.tsx
@@ -138,7 +138,7 @@ export interface SupervisorsViewProps {
   goToDatasource(datasource: string): void;
   goToQuery(queryWithContext: QueryWithContext): void;
   goToStreamingDataLoader(supervisorId: string): void;
-  goToTasks(supervisorId: string, type: string): void;
+  goToTasks(supervisorId: string, type: string | undefined): void;
   capabilities: Capabilities;
 }
 
@@ -175,6 +175,7 @@ function detailedStateToColor(detailedState: string): string {
     case 'UNHEALTHY_TASKS':
     case 'UNABLE_TO_CONNECT_TO_STREAM':
     case 'LOST_CONTACT_WITH_STREAM':
+    case 'INVALID_SPEC':
       return '#d5100a';
 
     case 'PENDING':
@@ -192,7 +193,8 @@ function detailedStateToColor(detailedState: string): string {
     case 'STOPPING':
       return '#e75c06';
 
-    case `SUSPENDED`:
+    case 'SUSPENDED':
+    case 'SCHEDULER_STOPPED':
       return '#ffbf00';
 
     default:
@@ -420,11 +422,8 @@ export class SupervisorsView extends React.PureComponent<
     this.supervisorQueryManager.rerunLastQuery();
   };
 
-  private getSupervisorActions(
-    id: string,
-    supervisorSuspended: boolean,
-    type: string,
-  ): BasicAction[] {
+  private getSupervisorActions(supervisor: SupervisorQueryResultRow): BasicAction[] {
+    const { supervisor_id, suspended, type } = supervisor;
     const { goToDatasource, goToStreamingDataLoader } = this.props;
 
     const actions: BasicAction[] = [];
@@ -433,30 +432,37 @@ export class SupervisorsView extends React.PureComponent<
         {
           icon: IconNames.MULTI_SELECT,
           title: 'Go to datasource',
-          onAction: () => goToDatasource(id),
+          onAction: () => goToDatasource(supervisor_id),
         },
         {
           icon: IconNames.CLOUD_UPLOAD,
           title: 'Open in data loader',
-          onAction: () => goToStreamingDataLoader(id),
+          onAction: () => goToStreamingDataLoader(supervisor_id),
         },
       );
     }
 
-    actions.push({
-      icon: supervisorSuspended ? IconNames.PLAY : IconNames.PAUSE,
-      title: supervisorSuspended ? 'Resume' : 'Suspend',
-      onAction: () =>
-        supervisorSuspended
-          ? this.setState({ resumeSupervisorId: id })
-          : this.setState({ suspendSupervisorId: id }),
-    });
+    actions.push(
+      {
+        icon: suspended ? IconNames.PLAY : IconNames.PAUSE,
+        title: suspended ? 'Resume' : 'Suspend',
+        onAction: () =>
+          suspended
+            ? this.setState({ resumeSupervisorId: supervisor_id })
+            : this.setState({ suspendSupervisorId: supervisor_id }),
+      },
+      {
+        icon: IconNames.GANTT_CHART,
+        title: 'Go to tasks',
+        onAction: () => this.goToTasksForSupervisor(supervisor),
+      },
+    );
 
-    if (!supervisorSuspended) {
+    if (!suspended) {
       actions.push({
         icon: IconNames.AUTOMATIC_UPDATES,
         title: 'Handoff early',
-        onAction: () => this.setState({ handoffSupervisorId: id }),
+        onAction: () => this.setState({ handoffSupervisorId: supervisor_id }),
       });
     }
 
@@ -464,21 +470,21 @@ export class SupervisorsView extends React.PureComponent<
       {
         icon: IconNames.STEP_BACKWARD,
         title: `Set ${type === 'kinesis' ? 'sequence numbers' : 'offsets'}`,
-        onAction: () => this.setState({ resetOffsetsSupervisorInfo: { id, type } }),
-        disabledReason: supervisorSuspended ? undefined : `Supervisor must be suspended`,
+        onAction: () => this.setState({ resetOffsetsSupervisorInfo: { id: supervisor_id, type } }),
+        disabledReason: suspended ? undefined : `Supervisor must be suspended`,
       },
       {
         icon: IconNames.STEP_BACKWARD,
         title: 'Hard reset',
         intent: Intent.DANGER,
-        onAction: () => this.setState({ resetSupervisorId: id }),
-        disabledReason: supervisorSuspended ? undefined : `Supervisor must be suspended`,
+        onAction: () => this.setState({ resetSupervisorId: supervisor_id }),
+        disabledReason: suspended ? undefined : `Supervisor must be suspended`,
       },
       {
         icon: IconNames.CROSS,
         title: 'Terminate',
         intent: Intent.DANGER,
-        onAction: () => this.setState({ terminateSupervisorId: id }),
+        onAction: () => this.setState({ terminateSupervisorId: supervisor_id }),
       },
     );
     return actions;
@@ -672,16 +678,37 @@ export class SupervisorsView extends React.PureComponent<
   private onSupervisorDetail(supervisor: SupervisorQueryResultRow) {
     this.setState({
       supervisorTableActionDialogId: supervisor.supervisor_id,
-      supervisorTableActionDialogActions: this.getSupervisorActions(
-        supervisor.supervisor_id,
-        supervisor.suspended,
-        supervisor.type,
-      ),
+      supervisorTableActionDialogActions: this.getSupervisorActions(supervisor),
     });
   }
 
+  private goToTasksForSupervisor(supervisor: SupervisorQueryResultRow) {
+    const { goToTasks } = this.props;
+    switch (supervisor.type) {
+      case 'kafka':
+      case 'kinesis':
+        goToTasks(supervisor.supervisor_id, `index_${supervisor.type}`);
+        return;
+
+      case 'autocompact':
+        goToTasks(supervisor.supervisor_id.replace(/^autocompact__/, ''), 'compact');
+        return;
+
+      case 'scheduled_batch':
+        goToTasks(
+          supervisor.supervisor_id.replace(/^scheduled_batch__/, '').replace(/__[0-9a-f-]+$/, ''),
+          'query_controller',
+        );
+        return;
+
+      default:
+        goToTasks(supervisor.supervisor_id, undefined);
+        return;
+    }
+  }
+
   private renderSupervisorTable() {
-    const { goToTasks, filters, onFiltersChange } = this.props;
+    const { filters, onFiltersChange } = this.props;
     const { supervisorsState, statsKey, visibleColumns, page, pageSize, sorted } = this.state;
 
     const supervisors = supervisorsState.data || [];
@@ -727,7 +754,7 @@ export class SupervisorsView extends React.PureComponent<
           {
             Header: 'Type',
             accessor: 'type',
-            width: 80,
+            width: 120,
             Cell: this.renderSupervisorFilterableCell('type'),
             show: visibleColumns.shown('Type'),
           },
@@ -741,15 +768,17 @@ export class SupervisorsView extends React.PureComponent<
           {
             Header: 'Status',
             id: 'detailed_state',
-            width: 150,
+            width: 170,
             Filter: suggestibleFilterInput([
               'CONNECTING_TO_STREAM',
               'CREATING_TASKS',
               'DISCOVERING_INITIAL_TASKS',
               'IDLE',
+              'INVALID_SPEC',
               'LOST_CONTACT_WITH_STREAM',
               'PENDING',
               'RUNNING',
+              'SCHEDULER_STOPPED',
               'STOPPING',
               'SUSPENDED',
               'UNABLE_TO_CONNECT_TO_STREAM',
@@ -825,10 +854,11 @@ export class SupervisorsView extends React.PureComponent<
               } else {
                 label = '';
               }
+
               return (
                 <TableClickableCell
                   tooltip="Go to tasks"
-                  onClick={() => goToTasks(original.supervisor_id, `index_${original.type}`)}
+                  onClick={() => this.goToTasksForSupervisor(original)}
                   hoverIcon={IconNames.ARROW_TOP_RIGHT}
                 >
                   {label}
@@ -971,14 +1001,11 @@ export class SupervisorsView extends React.PureComponent<
             width: ACTION_COLUMN_WIDTH,
             filterable: false,
             sortable: false,
-            Cell: row => {
-              const id = row.value;
-              const type = row.original.type;
-              const supervisorSuspended = row.original.suspended;
-              const supervisorActions = this.getSupervisorActions(id, supervisorSuspended, type);
+            Cell: ({ value: id, original }) => {
+              const supervisorActions = this.getSupervisorActions(original);
               return (
                 <ActionCell
-                  onDetail={() => this.onSupervisorDetail(row.original)}
+                  onDetail={() => this.onSupervisorDetail(original)}
                   actions={supervisorActions}
                   menuTitle={id}
                 />

From 73a7bb76454ca49e6d05f0b047a5afeed111394f Mon Sep 17 00:00:00 2001
From: Zoltan Haindrich <kirk@rxd.hu>
Date: Mon, 17 Mar 2025 09:45:11 +0100
Subject: [PATCH 33/99] Enable ComponentSuppliers to run queries using Dart
 (#17787)

Enables Calcite*Test-s and quidem tests to run queries with Dart.

needed some minor tweaks:

    changed to use interfaces at some places
    renamed DartWorkerClient to DartWorkerClientImpl and made DartWorkerClient an interface
    reused existing parts of the MSQ test system to run the query
---
 .../controller/DartControllerContext.java     |   6 +-
 .../DartControllerContextFactoryImpl.java     |  24 +-
 .../msq/dart/worker/DartWorkerClient.java     | 177 +--------------
 .../msq/dart/worker/DartWorkerClientImpl.java | 209 ++++++++++++++++++
 .../dart/worker/DartWorkerFactoryImpl.java    |   2 +-
 .../dart/worker/DartWorkerRetryPolicy.java    |   2 +-
 .../apache/druid/msq/exec/ControllerImpl.java |  18 +-
 .../controller/DartWorkerManagerTest.java     |   4 +-
 .../druid/msq/test/CalciteDartTest.java       | 144 ++++++++++++
 .../druid/msq/test/DartComponentSupplier.java | 156 +++++++++++++
 .../msq/test/MSQTestControllerContext.java    |   9 +-
 .../druid/msq/test/MSQTestWorkerClient.java   |  64 +++---
 .../TestDartControllerContextFactoryImpl.java | 157 +++++++++++++
 .../druid/sql/avatica/DartDruidMeta.java      |  38 ++++
 .../dart.iq                                   |  46 ++++
 .../druid/quidem/DruidAvaticaTestDriver.java  |  14 --
 .../druid/sql/calcite/QueryTestBuilder.java   |   4 +-
 .../druid/sql/calcite/util/CalciteTests.java  |   5 +-
 .../sql/calcite/util/QueryFrameworkUtils.java |  38 +++-
 .../sql/calcite/util/SqlTestFramework.java    |  50 ++++-
 .../calcite/util/TestTimelineServerView.java  |  33 ++-
 21 files changed, 936 insertions(+), 264 deletions(-)
 create mode 100644 extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerClientImpl.java
 create mode 100644 extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/CalciteDartTest.java
 create mode 100644 extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/DartComponentSupplier.java
 create mode 100644 extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/TestDartControllerContextFactoryImpl.java
 create mode 100644 extensions-core/multi-stage-query/src/test/java/org/apache/druid/sql/avatica/DartDruidMeta.java
 create mode 100644 extensions-core/multi-stage-query/src/test/quidem/org.apache.druid.msq.quidem.MSQQuidemTest/dart.iq

diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/controller/DartControllerContext.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/controller/DartControllerContext.java
index b7cf087a3f4d..c2257d160ed3 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/controller/DartControllerContext.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/controller/DartControllerContext.java
@@ -21,7 +21,7 @@
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.inject.Injector;
-import org.apache.druid.client.BrokerServerView;
+import org.apache.druid.client.TimelineServerView;
 import org.apache.druid.error.DruidException;
 import org.apache.druid.indexing.common.TaskLockType;
 import org.apache.druid.indexing.common.actions.TaskActionClient;
@@ -84,7 +84,7 @@ public class DartControllerContext implements ControllerContext
   private final ObjectMapper jsonMapper;
   private final DruidNode selfNode;
   private final DartWorkerClient workerClient;
-  private final BrokerServerView serverView;
+  private final TimelineServerView serverView;
   private final MemoryIntrospector memoryIntrospector;
   private final ServiceMetricEvent.Builder metricBuilder;
   private final ServiceEmitter emitter;
@@ -95,7 +95,7 @@ public DartControllerContext(
       final DruidNode selfNode,
       final DartWorkerClient workerClient,
       final MemoryIntrospector memoryIntrospector,
-      final BrokerServerView serverView,
+      final TimelineServerView serverView,
       final ServiceEmitter emitter
   )
   {
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/controller/DartControllerContextFactoryImpl.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/controller/DartControllerContextFactoryImpl.java
index 8cefb6af7ece..113714aa9b92 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/controller/DartControllerContextFactoryImpl.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/controller/DartControllerContextFactoryImpl.java
@@ -22,13 +22,13 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.inject.Inject;
 import com.google.inject.Injector;
-import org.apache.druid.client.BrokerServerView;
+import org.apache.druid.client.TimelineServerView;
 import org.apache.druid.guice.annotations.EscalatedGlobal;
 import org.apache.druid.guice.annotations.Json;
 import org.apache.druid.guice.annotations.Self;
 import org.apache.druid.guice.annotations.Smile;
 import org.apache.druid.java.util.emitter.service.ServiceEmitter;
-import org.apache.druid.msq.dart.worker.DartWorkerClient;
+import org.apache.druid.msq.dart.worker.DartWorkerClientImpl;
 import org.apache.druid.msq.exec.ControllerContext;
 import org.apache.druid.msq.exec.MemoryIntrospector;
 import org.apache.druid.rpc.ServiceClientFactory;
@@ -36,14 +36,14 @@
 
 public class DartControllerContextFactoryImpl implements DartControllerContextFactory
 {
-  private final Injector injector;
-  private final ObjectMapper jsonMapper;
-  private final ObjectMapper smileMapper;
-  private final DruidNode selfNode;
-  private final ServiceClientFactory serviceClientFactory;
-  private final BrokerServerView serverView;
-  private final MemoryIntrospector memoryIntrospector;
-  private final ServiceEmitter emitter;
+  protected final Injector injector;
+  protected final ObjectMapper jsonMapper;
+  protected final ObjectMapper smileMapper;
+  protected final DruidNode selfNode;
+  protected final ServiceClientFactory serviceClientFactory;
+  protected final TimelineServerView serverView;
+  protected final MemoryIntrospector memoryIntrospector;
+  protected final ServiceEmitter emitter;
 
   @Inject
   public DartControllerContextFactoryImpl(
@@ -53,7 +53,7 @@ public DartControllerContextFactoryImpl(
       @Self final DruidNode selfNode,
       @EscalatedGlobal final ServiceClientFactory serviceClientFactory,
       final MemoryIntrospector memoryIntrospector,
-      final BrokerServerView serverView,
+      final TimelineServerView serverView,
       final ServiceEmitter emitter
   )
   {
@@ -74,7 +74,7 @@ public ControllerContext newContext(final String queryId)
         injector,
         jsonMapper,
         selfNode,
-        new DartWorkerClient(queryId, serviceClientFactory, smileMapper, selfNode.getHostAndPortToUse()),
+        new DartWorkerClientImpl(queryId, serviceClientFactory, smileMapper, selfNode.getHostAndPortToUse()),
         memoryIntrospector,
         serverView,
         emitter
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerClient.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerClient.java
index 932300de217f..e048f9fd6d67 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerClient.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerClient.java
@@ -19,192 +19,21 @@
 
 package org.apache.druid.msq.dart.worker;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.jaxrs.smile.SmileMediaTypes;
 import com.google.common.util.concurrent.ListenableFuture;
-import com.google.errorprone.annotations.concurrent.GuardedBy;
-import it.unimi.dsi.fastutil.Pair;
-import org.apache.druid.error.DruidException;
-import org.apache.druid.java.util.common.logger.Logger;
-import org.apache.druid.java.util.http.client.response.HttpResponseHandler;
 import org.apache.druid.msq.dart.controller.DartWorkerManager;
-import org.apache.druid.msq.dart.controller.sql.DartSqlEngine;
-import org.apache.druid.msq.dart.worker.http.DartWorkerResource;
 import org.apache.druid.msq.exec.WorkerClient;
-import org.apache.druid.msq.rpc.BaseWorkerClientImpl;
-import org.apache.druid.rpc.FixedServiceLocator;
-import org.apache.druid.rpc.IgnoreHttpResponseHandler;
-import org.apache.druid.rpc.RequestBuilder;
-import org.apache.druid.rpc.ServiceClient;
-import org.apache.druid.rpc.ServiceClientFactory;
-import org.apache.druid.rpc.ServiceLocation;
-import org.apache.druid.rpc.ServiceRetryPolicy;
-import org.apache.druid.utils.CloseableUtils;
-import org.jboss.netty.handler.codec.http.HttpMethod;
 
-import javax.annotation.Nullable;
-import java.io.Closeable;
-import java.net.URI;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Dart implementation of {@link WorkerClient}. Uses the same {@link BaseWorkerClientImpl} as the task-based engine.
- * Each instance of this class is scoped to a single query.
- */
-public class DartWorkerClient extends BaseWorkerClientImpl
+public interface DartWorkerClient extends WorkerClient
 {
-  private static final Logger log = new Logger(DartWorkerClient.class);
-
-  private final String queryId;
-  private final ServiceClientFactory clientFactory;
-  private final ServiceRetryPolicy retryPolicy;
-
-  @Nullable
-  private final String controllerHost;
-
-  @GuardedBy("clientMap")
-  private final Map<String, Pair<ServiceClient, Closeable>> clientMap = new HashMap<>();
-
-  /**
-   * Create a worker client.
-   *
-   * @param queryId        dart query ID. see {@link DartSqlEngine#CTX_DART_QUERY_ID}
-   * @param clientFactory  service client factor
-   * @param smileMapper    Smile object mapper
-   * @param controllerHost Controller host (see {@link DartWorkerResource#HEADER_CONTROLLER_HOST}) if this is a
-   *                       controller-to-worker client. Null if this is a worker-to-worker client.
-   */
-  public DartWorkerClient(
-      final String queryId,
-      final ServiceClientFactory clientFactory,
-      final ObjectMapper smileMapper,
-      @Nullable final String controllerHost
-  )
-  {
-    super(smileMapper, SmileMediaTypes.APPLICATION_JACKSON_SMILE);
-    this.queryId = queryId;
-    this.clientFactory = clientFactory;
-    this.controllerHost = controllerHost;
-
-    if (controllerHost == null) {
-      // worker -> worker client. Retry HTTP 503 in case worker A starts up before worker B, and needs to
-      // contact it immediately.
-      this.retryPolicy = new DartWorkerRetryPolicy(true);
-    } else {
-      // controller -> worker client. Do not retry any HTTP error codes. If we retry HTTP 503 for controller -> worker,
-      // we can get stuck trying to contact workers that have exited.
-      this.retryPolicy = new DartWorkerRetryPolicy(false);
-    }
-  }
-
-  @Override
-  protected ServiceClient getClient(final String workerIdString)
-  {
-    final WorkerId workerId = WorkerId.fromString(workerIdString);
-    if (!queryId.equals(workerId.getQueryId())) {
-      throw DruidException.defensive("Unexpected queryId[%s]. Expected queryId[%s]", workerId.getQueryId(), queryId);
-    }
-
-    synchronized (clientMap) {
-      return clientMap.computeIfAbsent(workerId.getHostAndPort(), ignored -> makeNewClient(workerId)).left();
-    }
-  }
-
   /**
    * Close a single worker's clients. Used when that worker fails, so we stop trying to contact it.
    *
    * @param workerHost worker host:port
    */
-  public void closeClient(final String workerHost)
-  {
-    synchronized (clientMap) {
-      final Pair<ServiceClient, Closeable> clientPair = clientMap.remove(workerHost);
-      if (clientPair != null) {
-        CloseableUtils.closeAndWrapExceptions(clientPair.right());
-      }
-    }
-  }
-
-  /**
-   * Close all outstanding clients.
-   */
-  @Override
-  public void close()
-  {
-    synchronized (clientMap) {
-      for (Map.Entry<String, Pair<ServiceClient, Closeable>> entry : clientMap.entrySet()) {
-        CloseableUtils.closeAndSuppressExceptions(
-            entry.getValue().right(),
-            e -> log.warn(e, "Failed to close client[%s]", entry.getKey())
-        );
-      }
-
-      clientMap.clear();
-    }
-  }
+  void closeClient(String hostAndPort);
 
   /**
    * Stops a worker. Dart-only API, used by the {@link DartWorkerManager}.
    */
-  public ListenableFuture<?> stopWorker(String workerId)
-  {
-    return getClient(workerId).asyncRequest(
-        new RequestBuilder(HttpMethod.POST, "/stop"),
-        IgnoreHttpResponseHandler.INSTANCE
-    );
-  }
-
-  /**
-   * Create a new client. Called by {@link #getClient(String)} if a new one is needed.
-   */
-  private Pair<ServiceClient, Closeable> makeNewClient(final WorkerId workerId)
-  {
-    final URI uri = workerId.toUri();
-    final FixedServiceLocator locator = new FixedServiceLocator(ServiceLocation.fromUri(uri));
-    final ServiceClient baseClient =
-        clientFactory.makeClient(workerId.toString(), locator, retryPolicy);
-    final ServiceClient client;
-
-    if (controllerHost != null) {
-      client = new ControllerDecoratedClient(baseClient, controllerHost);
-    } else {
-      client = baseClient;
-    }
-
-    return Pair.of(client, locator);
-  }
-
-  /**
-   * Service client that adds the {@link DartWorkerResource#HEADER_CONTROLLER_HOST} header.
-   */
-  private static class ControllerDecoratedClient implements ServiceClient
-  {
-    private final ServiceClient delegate;
-    private final String controllerHost;
-
-    ControllerDecoratedClient(final ServiceClient delegate, final String controllerHost)
-    {
-      this.delegate = delegate;
-      this.controllerHost = controllerHost;
-    }
-
-    @Override
-    public <IntermediateType, FinalType> ListenableFuture<FinalType> asyncRequest(
-        final RequestBuilder requestBuilder,
-        final HttpResponseHandler<IntermediateType, FinalType> handler
-    )
-    {
-      return delegate.asyncRequest(
-          requestBuilder.header(DartWorkerResource.HEADER_CONTROLLER_HOST, controllerHost),
-          handler
-      );
-    }
-
-    @Override
-    public ServiceClient withRetryPolicy(final ServiceRetryPolicy retryPolicy)
-    {
-      return new ControllerDecoratedClient(delegate.withRetryPolicy(retryPolicy), controllerHost);
-    }
-  }
+  ListenableFuture<?> stopWorker(String workerId);
 }
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerClientImpl.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerClientImpl.java
new file mode 100644
index 000000000000..adfebee111c9
--- /dev/null
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerClientImpl.java
@@ -0,0 +1,209 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.msq.dart.worker;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.jaxrs.smile.SmileMediaTypes;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import it.unimi.dsi.fastutil.Pair;
+import org.apache.druid.error.DruidException;
+import org.apache.druid.java.util.common.logger.Logger;
+import org.apache.druid.java.util.http.client.response.HttpResponseHandler;
+import org.apache.druid.msq.dart.controller.sql.DartSqlEngine;
+import org.apache.druid.msq.dart.worker.http.DartWorkerResource;
+import org.apache.druid.msq.exec.WorkerClient;
+import org.apache.druid.msq.rpc.BaseWorkerClientImpl;
+import org.apache.druid.rpc.FixedServiceLocator;
+import org.apache.druid.rpc.IgnoreHttpResponseHandler;
+import org.apache.druid.rpc.RequestBuilder;
+import org.apache.druid.rpc.ServiceClient;
+import org.apache.druid.rpc.ServiceClientFactory;
+import org.apache.druid.rpc.ServiceLocation;
+import org.apache.druid.rpc.ServiceRetryPolicy;
+import org.apache.druid.utils.CloseableUtils;
+import org.jboss.netty.handler.codec.http.HttpMethod;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.net.URI;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Dart implementation of {@link WorkerClient}. Uses the same {@link BaseWorkerClientImpl} as the task-based engine.
+ * Each instance of this class is scoped to a single query.
+ */
+public class DartWorkerClientImpl extends BaseWorkerClientImpl implements DartWorkerClient
+{
+  private static final Logger log = new Logger(DartWorkerClientImpl.class);
+
+  private final String queryId;
+  private final ServiceClientFactory clientFactory;
+  private final ServiceRetryPolicy retryPolicy;
+
+  @Nullable
+  private final String controllerHost;
+
+  @GuardedBy("clientMap")
+  private final Map<String, Pair<ServiceClient, Closeable>> clientMap = new HashMap<>();
+
+  /**
+   * Create a worker client.
+   *
+   * @param queryId        dart query ID. see {@link DartSqlEngine#CTX_DART_QUERY_ID}
+   * @param clientFactory  service client factor
+   * @param smileMapper    Smile object mapper
+   * @param controllerHost Controller host (see {@link DartWorkerResource#HEADER_CONTROLLER_HOST}) if this is a
+   *                       controller-to-worker client. Null if this is a worker-to-worker client.
+   */
+  public DartWorkerClientImpl(
+      final String queryId,
+      final ServiceClientFactory clientFactory,
+      final ObjectMapper smileMapper,
+      @Nullable final String controllerHost
+  )
+  {
+    super(smileMapper, SmileMediaTypes.APPLICATION_JACKSON_SMILE);
+    this.queryId = queryId;
+    this.clientFactory = clientFactory;
+    this.controllerHost = controllerHost;
+
+    if (controllerHost == null) {
+      // worker -> worker client. Retry HTTP 503 in case worker A starts up before worker B, and needs to
+      // contact it immediately.
+      this.retryPolicy = new DartWorkerRetryPolicy(true);
+    } else {
+      // controller -> worker client. Do not retry any HTTP error codes. If we retry HTTP 503 for controller -> worker,
+      // we can get stuck trying to contact workers that have exited.
+      this.retryPolicy = new DartWorkerRetryPolicy(false);
+    }
+  }
+
+  @Override
+  protected ServiceClient getClient(final String workerIdString)
+  {
+    final WorkerId workerId = WorkerId.fromString(workerIdString);
+    if (!queryId.equals(workerId.getQueryId())) {
+      throw DruidException.defensive("Unexpected queryId[%s]. Expected queryId[%s]", workerId.getQueryId(), queryId);
+    }
+
+    synchronized (clientMap) {
+      return clientMap.computeIfAbsent(workerId.getHostAndPort(), ignored -> makeNewClient(workerId)).left();
+    }
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  @Override
+  public void closeClient(final String workerHost)
+  {
+    synchronized (clientMap) {
+      final Pair<ServiceClient, Closeable> clientPair = clientMap.remove(workerHost);
+      if (clientPair != null) {
+        CloseableUtils.closeAndWrapExceptions(clientPair.right());
+      }
+    }
+  }
+
+  /**
+   * Close all outstanding clients.
+   */
+  @Override
+  public void close()
+  {
+    synchronized (clientMap) {
+      for (Map.Entry<String, Pair<ServiceClient, Closeable>> entry : clientMap.entrySet()) {
+        CloseableUtils.closeAndSuppressExceptions(
+            entry.getValue().right(),
+            e -> log.warn(e, "Failed to close client[%s]", entry.getKey())
+        );
+      }
+
+      clientMap.clear();
+    }
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  @Override
+  public ListenableFuture<?> stopWorker(String workerId)
+  {
+    return getClient(workerId).asyncRequest(
+        new RequestBuilder(HttpMethod.POST, "/stop"),
+        IgnoreHttpResponseHandler.INSTANCE
+    );
+  }
+
+  /**
+   * Create a new client. Called by {@link #getClient(String)} if a new one is needed.
+   */
+  protected Pair<ServiceClient, Closeable> makeNewClient(final WorkerId workerId)
+  {
+    final URI uri = workerId.toUri();
+    final FixedServiceLocator locator = new FixedServiceLocator(ServiceLocation.fromUri(uri));
+    final ServiceClient baseClient =
+        clientFactory.makeClient(workerId.toString(), locator, retryPolicy);
+    final ServiceClient client;
+
+    if (controllerHost != null) {
+      client = new ControllerDecoratedClient(baseClient, controllerHost);
+    } else {
+      client = baseClient;
+    }
+
+    return Pair.of(client, locator);
+  }
+
+  /**
+   * Service client that adds the {@link DartWorkerResource#HEADER_CONTROLLER_HOST} header.
+   */
+  private static class ControllerDecoratedClient implements ServiceClient
+  {
+    private final ServiceClient delegate;
+    private final String controllerHost;
+
+    ControllerDecoratedClient(final ServiceClient delegate, final String controllerHost)
+    {
+      this.delegate = delegate;
+      this.controllerHost = controllerHost;
+    }
+
+    @Override
+    public <IntermediateType, FinalType> ListenableFuture<FinalType> asyncRequest(
+        final RequestBuilder requestBuilder,
+        final HttpResponseHandler<IntermediateType, FinalType> handler
+    )
+    {
+      return delegate.asyncRequest(
+          requestBuilder.header(DartWorkerResource.HEADER_CONTROLLER_HOST, controllerHost),
+          handler
+      );
+    }
+
+    @Override
+    public ServiceClient withRetryPolicy(final ServiceRetryPolicy retryPolicy)
+    {
+      return new ControllerDecoratedClient(delegate.withRetryPolicy(retryPolicy), controllerHost);
+    }
+  }
+}
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerFactoryImpl.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerFactoryImpl.java
index 34da929060d8..1960924b4b67 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerFactoryImpl.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerFactoryImpl.java
@@ -101,7 +101,7 @@ public Worker build(String queryId, String controllerHost, File tempDir, QueryCo
         selfNode,
         jsonMapper,
         injector,
-        new DartWorkerClient(queryId, serviceClientFactory, smileMapper, null),
+        new DartWorkerClientImpl(queryId, serviceClientFactory, smileMapper, null),
         processingConfig,
         segmentWrangler,
         groupingEngine,
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerRetryPolicy.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerRetryPolicy.java
index 5dbfe98ef0c5..9e4d2f668039 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerRetryPolicy.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerRetryPolicy.java
@@ -25,7 +25,7 @@
 import org.jboss.netty.handler.codec.http.HttpResponseStatus;
 
 /**
- * Retry policy for {@link DartWorkerClient}. This is a {@link StandardRetryPolicy#unlimited()} with
+ * Retry policy for {@link DartWorkerClientImpl}. This is a {@link StandardRetryPolicy#unlimited()} with
  * {@link #retryHttpResponse(HttpResponse)} customized to retry fewer HTTP error codes.
  */
 public class DartWorkerRetryPolicy implements ServiceRetryPolicy
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/exec/ControllerImpl.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/exec/ControllerImpl.java
index b370ab586433..cc73ea42c1a4 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/exec/ControllerImpl.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/exec/ControllerImpl.java
@@ -350,6 +350,15 @@ private MSQTaskReportPayload runInternal(final QueryListener queryListener, fina
       context.registerController(this, closer);
       queryDef = initializeQueryDefAndState(closer);
 
+      this.netClient = closer.register(new ExceptionWrappingWorkerClient(context.newWorkerClient()));
+      this.workerSketchFetcher = new WorkerSketchFetcher(
+          netClient,
+          workerManager,
+          queryKernelConfig.isFaultTolerant(),
+          MultiStageQueryContext.getSketchEncoding(querySpec.getContext())
+      );
+      closer.register(workerSketchFetcher::close);
+
       // Execution-related: run the multi-stage QueryDefinition.
       final InputSpecSlicerFactory inputSpecSlicerFactory =
           makeInputSpecSlicerFactory(context.newTableInputSpecSlicer(workerManager));
@@ -589,7 +598,6 @@ public void addToKernelManipulationQueue(Consumer<ControllerQueryKernel> kernelC
   private QueryDefinition initializeQueryDefAndState(final Closer closer)
   {
     this.selfDruidNode = context.selfNode();
-    this.netClient = closer.register(new ExceptionWrappingWorkerClient(context.newWorkerClient()));
     this.queryKernelConfig = context.queryKernelConfig(queryId, querySpec);
 
     final QueryContext queryContext = querySpec.getContext();
@@ -653,13 +661,7 @@ private QueryDefinition initializeQueryDefAndState(final Closer closer)
                 )
             )
     );
-    this.workerSketchFetcher = new WorkerSketchFetcher(
-        netClient,
-        workerManager,
-        queryKernelConfig.isFaultTolerant(),
-        MultiStageQueryContext.getSketchEncoding(queryContext)
-    );
-    closer.register(workerSketchFetcher::close);
+
 
     return queryDef;
   }
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/dart/controller/DartWorkerManagerTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/dart/controller/DartWorkerManagerTest.java
index f4441c984e70..ea781e2e9920 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/dart/controller/DartWorkerManagerTest.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/dart/controller/DartWorkerManagerTest.java
@@ -28,7 +28,7 @@
 import org.apache.druid.error.DruidException;
 import org.apache.druid.indexer.TaskState;
 import org.apache.druid.java.util.common.ISE;
-import org.apache.druid.msq.dart.worker.DartWorkerClient;
+import org.apache.druid.msq.dart.worker.DartWorkerClientImpl;
 import org.apache.druid.msq.dart.worker.WorkerId;
 import org.apache.druid.msq.exec.WorkerManager;
 import org.apache.druid.msq.exec.WorkerStats;
@@ -56,7 +56,7 @@ public class DartWorkerManagerTest
   private AutoCloseable mockCloser;
 
   @Mock
-  private DartWorkerClient workerClient;
+  private DartWorkerClientImpl workerClient;
 
   @BeforeEach
   public void setUp()
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/CalciteDartTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/CalciteDartTest.java
new file mode 100644
index 000000000000..f37162eb7aa7
--- /dev/null
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/CalciteDartTest.java
@@ -0,0 +1,144 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.msq.test;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import org.apache.druid.msq.dart.controller.sql.DartSqlEngine;
+import org.apache.druid.sql.calcite.BaseCalciteQueryTest;
+import org.apache.druid.sql.calcite.QueryTestBuilder;
+import org.apache.druid.sql.calcite.SqlTestFrameworkConfig;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+import java.util.UUID;
+
+@SqlTestFrameworkConfig.ComponentSupplier(DartComponentSupplier.class)
+public class CalciteDartTest extends BaseCalciteQueryTest
+{
+  @Override
+  protected QueryTestBuilder testBuilder()
+  {
+    return new QueryTestBuilder(new CalciteTestConfig(true))
+        .queryContext(
+            ImmutableMap.<String, Object>builder()
+                .put(DartSqlEngine.CTX_DART_QUERY_ID, UUID.randomUUID().toString())
+                .build()
+        )
+        .skipVectorize(true)
+        .verifyNativeQueries(new VerifyMSQSupportedNativeQueriesPredicate());
+  }
+
+  @Test
+  public void testSelect1()
+  {
+    testBuilder()
+        .sql("SELECT 1")
+        .expectedResults(ImmutableList.of(new Object[] {1}))
+        .run();
+  }
+
+  @Test
+  public void testSelectFromFoo()
+  {
+    testBuilder()
+        .sql("SELECT 2 from foo order by dim1")
+        .expectedResults(
+            ImmutableList.of(
+                new Object[] {2},
+                new Object[] {2},
+                new Object[] {2},
+                new Object[] {2},
+                new Object[] {2},
+                new Object[] {2}
+            )
+        )
+        .run();
+  }
+
+  @Test
+  @Disabled("this case currently stalls")
+  public void testSelectFromFooLimit2()
+  {
+    testBuilder()
+        .sql("SELECT 2 from foo limit 2")
+        .expectedResults(
+            ImmutableList.of(
+                new Object[] {2},
+                new Object[] {2}
+            )
+        )
+        .run();
+  }
+
+
+  @Test
+  public void testSelectDim1FromFoo11()
+  {
+    testBuilder()
+        .sql("SELECT dim1 from foo")
+        .expectedResults(
+            ImmutableList.of(
+                new Object[] {""},
+                new Object[] {"10.1"},
+                new Object[] {"2"},
+                new Object[] {"1"},
+                new Object[] {"def"},
+                new Object[] {"abc"}
+            )
+        )
+        .run();
+  }
+
+  @Test
+  public void testGby()
+  {
+    testBuilder()
+        .sql("SELECT 3 from foo group by dim2")
+        .expectedResults(
+            ImmutableList.of(
+                new Object[] {3},
+                new Object[] {3},
+                new Object[] {3},
+                new Object[] {3}
+            )
+        )
+        .run();
+  }
+
+  @Test
+  public void testComplexFromFoo()
+  {
+    String sql = "SELECT dim1, COUNT(*) FROM druid.foo "
+        + "WHERE dim1 NOT IN ('ghi', 'abc', 'def') AND dim1 IS NOT NULL "
+        + "GROUP BY dim1";
+    testBuilder()
+        .sql(sql)
+        .expectedResults(
+            ImmutableList.of(
+                new Object[] {"", 1L},
+                new Object[] {"1", 1L},
+                new Object[] {"10.1", 1L},
+                new Object[] {"2", 1L}
+            )
+        )
+        .run();
+  }
+}
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/DartComponentSupplier.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/DartComponentSupplier.java
new file mode 100644
index 000000000000..7cfac91a4ce5
--- /dev/null
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/DartComponentSupplier.java
@@ -0,0 +1,156 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.msq.test;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.inject.Binder;
+import com.google.inject.Injector;
+import com.google.inject.Provides;
+import org.apache.druid.collections.NonBlockingPool;
+import org.apache.druid.discovery.DruidNodeDiscoveryProvider;
+import org.apache.druid.guice.LazySingleton;
+import org.apache.druid.guice.annotations.EscalatedGlobal;
+import org.apache.druid.guice.annotations.Merging;
+import org.apache.druid.initialization.DruidModule;
+import org.apache.druid.java.util.http.client.HttpClient;
+import org.apache.druid.msq.dart.Dart;
+import org.apache.druid.msq.dart.controller.DartControllerContextFactory;
+import org.apache.druid.msq.dart.controller.sql.DartSqlEngine;
+import org.apache.druid.msq.dart.guice.DartControllerModule;
+import org.apache.druid.msq.dart.guice.DartModules;
+import org.apache.druid.msq.dart.guice.DartWorkerMemoryManagementModule;
+import org.apache.druid.msq.dart.guice.DartWorkerModule;
+import org.apache.druid.msq.exec.Worker;
+import org.apache.druid.query.TestBufferPool;
+import org.apache.druid.rpc.ServiceClientFactory;
+import org.apache.druid.rpc.guice.ServiceClientModule;
+import org.apache.druid.server.QueryLifecycleFactory;
+import org.apache.druid.sql.avatica.DartDruidMeta;
+import org.apache.druid.sql.avatica.DruidMeta;
+import org.apache.druid.sql.calcite.TempDirProducer;
+import org.apache.druid.sql.calcite.run.SqlEngine;
+import org.apache.druid.sql.calcite.util.DruidModuleCollection;
+import org.apache.druid.sql.calcite.util.SqlTestFramework.StandardComponentSupplier;
+
+import java.nio.ByteBuffer;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+
+public class DartComponentSupplier extends AbstractMSQComponentSupplierDelegate
+{
+  public DartComponentSupplier(TempDirProducer tempFolderProducer)
+  {
+    super(new StandardComponentSupplier(tempFolderProducer));
+  }
+
+  @Override
+  public void gatherProperties(Properties properties)
+  {
+    super.gatherProperties(properties);
+    properties.put(DartModules.DART_ENABLED_PROPERTY, "true");
+  }
+
+  @Override
+  public DruidModule getCoreModule()
+  {
+    return DruidModuleCollection.of(
+        super.getCoreModule(),
+        new DartControllerModule(),
+        new DartWorkerModule(),
+        new DartWorkerMemoryManagementModule(),
+        new DartTestCoreModule()
+    );
+  }
+
+  @Override
+  public DruidModule getOverrideModule()
+  {
+    return DruidModuleCollection.of(
+        super.getOverrideModule(),
+        new DartTestOverrideModule()
+    );
+  }
+
+  @Override
+  public SqlEngine createEngine(
+      QueryLifecycleFactory qlf,
+      ObjectMapper queryJsonMapper,
+      Injector injector)
+  {
+    return injector.getInstance(DartSqlEngine.class);
+  }
+
+  static class DartTestCoreModule implements DruidModule
+  {
+    @Provides
+    @EscalatedGlobal
+    final ServiceClientFactory getServiceClientFactory(HttpClient ht)
+    {
+      return ServiceClientModule.makeServiceClientFactory(ht);
+
+    }
+
+    @Provides
+    final DruidNodeDiscoveryProvider getDiscoveryProvider()
+    {
+      return null;
+    }
+
+    @Override
+    public void configure(Binder binder)
+    {
+    }
+  }
+
+  static class DartTestOverrideModule implements DruidModule
+  {
+
+    @Provides
+    @LazySingleton
+    public DruidMeta createMeta(DartDruidMeta druidMeta)
+    {
+      return druidMeta;
+    }
+
+    @Override
+    public void configure(Binder binder)
+    {
+      binder.bind(DartControllerContextFactory.class)
+          .to(TestDartControllerContextFactoryImpl.class)
+          .in(LazySingleton.class);
+    }
+
+    @Provides
+    @Merging
+    NonBlockingPool<ByteBuffer> makeMergingBuffer(TestBufferPool bufferPool)
+    {
+      return bufferPool;
+    }
+
+    @Provides
+    @LazySingleton
+    @Dart
+    Map<String, Worker> workerMap()
+    {
+      return new HashMap<String, Worker>();
+    }
+  }
+}
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestControllerContext.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestControllerContext.java
index 6e632a4869ca..e1755757d04f 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestControllerContext.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestControllerContext.java
@@ -44,6 +44,7 @@
 import org.apache.druid.java.util.common.concurrent.Execs;
 import org.apache.druid.java.util.common.io.Closer;
 import org.apache.druid.java.util.common.logger.Logger;
+import org.apache.druid.msq.dart.controller.DartControllerContextFactory;
 import org.apache.druid.msq.exec.Controller;
 import org.apache.druid.msq.exec.ControllerContext;
 import org.apache.druid.msq.exec.ControllerMemoryParameters;
@@ -84,7 +85,7 @@
 import java.util.concurrent.ConcurrentMap;
 import java.util.stream.Collectors;
 
-public class MSQTestControllerContext implements ControllerContext
+public class MSQTestControllerContext implements ControllerContext, DartControllerContextFactory
 {
   private static final Logger log = new Logger(MSQTestControllerContext.class);
   private static final int NUM_WORKERS = 4;
@@ -387,4 +388,10 @@ public WorkerClient newWorkerClient()
   {
     return new MSQTestWorkerClient(inMemoryWorkers);
   }
+
+  @Override
+  public ControllerContext newContext(String queryId)
+  {
+    return this;
+  }
 }
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestWorkerClient.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestWorkerClient.java
index 4c7ccd72efd0..9f482912f315 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestWorkerClient.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestWorkerClient.java
@@ -21,6 +21,7 @@
 
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.druid.common.guava.FutureUtils;
 import org.apache.druid.frame.channel.ReadableByteChunksFrameChannel;
 import org.apache.druid.frame.key.ClusterByPartitions;
 import org.apache.druid.java.util.common.ISE;
@@ -32,14 +33,13 @@
 import org.apache.druid.msq.rpc.SketchEncoding;
 import org.apache.druid.msq.statistics.ClusterByStatisticsSnapshot;
 
-import java.io.InputStream;
 import java.util.Arrays;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 public class MSQTestWorkerClient implements WorkerClient
 {
-  private final Map<String, Worker> inMemoryWorkers;
+  protected final Map<String, Worker> inMemoryWorkers;
   private final AtomicBoolean closed = new AtomicBoolean();
 
   public MSQTestWorkerClient(Map<String, Worker> inMemoryWorkers)
@@ -50,10 +50,20 @@ public MSQTestWorkerClient(Map<String, Worker> inMemoryWorkers)
   @Override
   public ListenableFuture<Void> postWorkOrder(String workerTaskId, WorkOrder workOrder)
   {
-    inMemoryWorkers.get(workerTaskId).postWorkOrder(workOrder);
+    getWorkerFor(workerTaskId).postWorkOrder(workOrder);
     return Futures.immediateFuture(null);
   }
 
+  protected Worker getWorkerFor(String workerTaskId)
+  {
+    return inMemoryWorkers.computeIfAbsent(workerTaskId, this::newWorker);
+  }
+
+  protected Worker newWorker(String workerId)
+  {
+    throw new RuntimeException("Not implemented!");
+  }
+
   @Override
   public ListenableFuture<ClusterByStatisticsSnapshot> fetchClusterByStatisticsSnapshot(
       String workerTaskId,
@@ -61,7 +71,7 @@ public ListenableFuture<ClusterByStatisticsSnapshot> fetchClusterByStatisticsSna
       SketchEncoding sketchEncoding
   )
   {
-    return Futures.immediateFuture(inMemoryWorkers.get(workerTaskId).fetchStatisticsSnapshot(stageId));
+    return Futures.immediateFuture(getWorkerFor(workerTaskId).fetchStatisticsSnapshot(stageId));
   }
 
   @Override
@@ -73,7 +83,7 @@ public ListenableFuture<ClusterByStatisticsSnapshot> fetchClusterByStatisticsSna
   )
   {
     return Futures.immediateFuture(
-        inMemoryWorkers.get(workerTaskId).fetchStatisticsSnapshotForTimeChunk(stageId, timeChunk)
+        getWorkerFor(workerTaskId).fetchStatisticsSnapshotForTimeChunk(stageId, timeChunk)
     );
   }
 
@@ -85,7 +95,7 @@ public ListenableFuture<Void> postResultPartitionBoundaries(
   )
   {
     try {
-      inMemoryWorkers.get(workerTaskId).postResultPartitionBoundaries(stageId, partitionBoundaries);
+      getWorkerFor(workerTaskId).postResultPartitionBoundaries(stageId, partitionBoundaries);
       return Futures.immediateFuture(null);
     }
     catch (Exception e) {
@@ -96,21 +106,21 @@ public ListenableFuture<Void> postResultPartitionBoundaries(
   @Override
   public ListenableFuture<Void> postCleanupStage(String workerTaskId, StageId stageId)
   {
-    inMemoryWorkers.get(workerTaskId).postCleanupStage(stageId);
+    getWorkerFor(workerTaskId).postCleanupStage(stageId);
     return Futures.immediateFuture(null);
   }
 
   @Override
   public ListenableFuture<Void> postFinish(String taskId)
   {
-    inMemoryWorkers.get(taskId).postFinish();
+    getWorkerFor(taskId).postFinish();
     return Futures.immediateFuture(null);
   }
 
   @Override
   public ListenableFuture<CounterSnapshotsTree> getCounters(String taskId)
   {
-    return Futures.immediateFuture(inMemoryWorkers.get(taskId).getCounters());
+    return Futures.immediateFuture(getWorkerFor(taskId).getCounters());
   }
 
   @Override
@@ -122,22 +132,25 @@ public ListenableFuture<Boolean> fetchChannelData(
       final ReadableByteChunksFrameChannel channel
   )
   {
-    try (InputStream inputStream =
-             inMemoryWorkers.get(workerTaskId).readStageOutput(stageId, partitionNumber, offset).get()) {
-      byte[] buffer = new byte[8 * 1024];
-      boolean didRead = false;
-      int bytesRead;
-      while ((bytesRead = inputStream.read(buffer)) != -1) {
-        channel.addChunk(Arrays.copyOf(buffer, bytesRead));
-        didRead = true;
-      }
-      inputStream.close();
-
-      return Futures.immediateFuture(!didRead);
-    }
-    catch (Exception e) {
-      throw new ISE(e, "Error reading frame file channel");
-    }
+    return FutureUtils.transform(
+        getWorkerFor(workerTaskId).readStageOutput(stageId, partitionNumber, offset),
+        inputStream -> {
+          try {
+            byte[] buffer = new byte[8 * 1024];
+            boolean didRead = false;
+            int bytesRead;
+            while ((bytesRead = inputStream.read(buffer)) != -1) {
+              channel.addChunk(Arrays.copyOf(buffer, bytesRead));
+              didRead = true;
+            }
+            inputStream.close();
+            return !didRead;
+          }
+          catch (Exception e) {
+            throw new ISE(e, "Error reading frame file channel");
+          }
+        }
+    );
   }
 
   @Override
@@ -145,6 +158,7 @@ public void close()
   {
     if (closed.compareAndSet(false, true)) {
       inMemoryWorkers.forEach((k, v) -> v.stop());
+      inMemoryWorkers.clear();
     }
   }
 }
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/TestDartControllerContextFactoryImpl.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/TestDartControllerContextFactoryImpl.java
new file mode 100644
index 000000000000..89209f012529
--- /dev/null
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/TestDartControllerContextFactoryImpl.java
@@ -0,0 +1,157 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.msq.test;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.inject.Inject;
+import com.google.inject.Injector;
+import org.apache.druid.client.TimelineServerView;
+import org.apache.druid.guice.annotations.EscalatedGlobal;
+import org.apache.druid.guice.annotations.Json;
+import org.apache.druid.guice.annotations.Self;
+import org.apache.druid.guice.annotations.Smile;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.msq.dart.Dart;
+import org.apache.druid.msq.dart.controller.DartControllerContext;
+import org.apache.druid.msq.dart.controller.DartControllerContextFactoryImpl;
+import org.apache.druid.msq.dart.worker.DartWorkerClient;
+import org.apache.druid.msq.exec.Controller;
+import org.apache.druid.msq.exec.ControllerContext;
+import org.apache.druid.msq.exec.MemoryIntrospector;
+import org.apache.druid.msq.exec.Worker;
+import org.apache.druid.msq.exec.WorkerImpl;
+import org.apache.druid.msq.exec.WorkerStorageParameters;
+import org.apache.druid.msq.kernel.StageId;
+import org.apache.druid.msq.kernel.WorkOrder;
+import org.apache.druid.rpc.ServiceClientFactory;
+import org.apache.druid.server.DruidNode;
+
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class TestDartControllerContextFactoryImpl extends DartControllerContextFactoryImpl
+{
+  private Map<String, Worker> workerMap;
+  public Controller controller;
+
+  @Inject
+  public TestDartControllerContextFactoryImpl(
+      final Injector injector,
+      @Json final ObjectMapper jsonMapper,
+      @Smile final ObjectMapper smileMapper,
+      @Self final DruidNode selfNode,
+      @EscalatedGlobal final ServiceClientFactory serviceClientFactory,
+      final MemoryIntrospector memoryIntrospector,
+      final TimelineServerView serverView,
+      final ServiceEmitter emitter,
+      @Dart Map<String, Worker> workerMap)
+  {
+    super(injector, jsonMapper, smileMapper, selfNode, serviceClientFactory, memoryIntrospector, serverView, emitter);
+    this.workerMap = workerMap;
+  }
+
+  @Override
+  public ControllerContext newContext(String queryId)
+  {
+    return new DartControllerContext(
+        injector,
+        jsonMapper,
+        selfNode,
+        new DartTestWorkerClient(),
+        memoryIntrospector,
+        serverView,
+        emitter
+    )
+    {
+      @Override
+      public void registerController(Controller currentController, Closer closer)
+      {
+        super.registerController(currentController, closer);
+        controller = currentController;
+      }
+    };
+  }
+
+  public class DartTestWorkerClient extends MSQTestWorkerClient implements DartWorkerClient
+  {
+    private final ExecutorService EXECUTOR = Executors.newCachedThreadPool();
+
+    public DartTestWorkerClient()
+    {
+      super(workerMap);
+    }
+
+    @Override
+    protected Worker newWorker(String workerId)
+    {
+      String queryId = workerId;
+      Worker worker = new WorkerImpl(
+          null,
+          new MSQTestWorkerContext(
+              queryId,
+              inMemoryWorkers,
+              controller,
+              jsonMapper,
+              injector,
+              MSQTestBase.makeTestWorkerMemoryParameters(),
+              WorkerStorageParameters.createInstanceForTests(Long.MAX_VALUE)
+          )
+      );
+
+      EXECUTOR.submit(() -> {
+        try {
+          worker.run();
+        }
+        catch (Exception e) {
+          throw new RuntimeException(e);
+        }
+      });
+
+      return worker;
+    }
+
+    @Override
+    public ListenableFuture<Void> postWorkOrder(String workerTaskId, WorkOrder workOrder)
+    {
+      return super.postWorkOrder(workerTaskId, workOrder);
+    }
+
+    @Override
+    public ListenableFuture<Void> postCleanupStage(String workerTaskId, StageId stageId)
+    {
+      return super.postCleanupStage(workerTaskId, stageId);
+
+    }
+
+    @Override
+    public void closeClient(String hostAndPort)
+    {
+    }
+
+    @Override
+    public ListenableFuture<?> stopWorker(String workerId)
+    {
+      return null;
+    }
+  }
+}
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/sql/avatica/DartDruidMeta.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/sql/avatica/DartDruidMeta.java
new file mode 100644
index 000000000000..48d2f831c2d8
--- /dev/null
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/sql/avatica/DartDruidMeta.java
@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.sql.avatica;
+
+import com.google.inject.Inject;
+import org.apache.druid.msq.dart.Dart;
+import org.apache.druid.server.security.AuthenticatorMapper;
+import org.apache.druid.sql.SqlStatementFactory;
+
+public class DartDruidMeta extends DruidMeta
+{
+  @Inject
+  public DartDruidMeta(
+      final @Dart SqlStatementFactory sqlStatementFactory,
+      final AvaticaServerConfig config,
+      final ErrorHandler errorHandler,
+      final AuthenticatorMapper authMapper)
+  {
+    super(sqlStatementFactory, config, errorHandler, authMapper);
+  }
+}
diff --git a/extensions-core/multi-stage-query/src/test/quidem/org.apache.druid.msq.quidem.MSQQuidemTest/dart.iq b/extensions-core/multi-stage-query/src/test/quidem/org.apache.druid.msq.quidem.MSQQuidemTest/dart.iq
new file mode 100644
index 000000000000..d232a52ac20f
--- /dev/null
+++ b/extensions-core/multi-stage-query/src/test/quidem/org.apache.druid.msq.quidem.MSQQuidemTest/dart.iq
@@ -0,0 +1,46 @@
+!set dartQueryId 00000000-0000-0000-0000-000000000000
+!use druidtest://?componentSupplier=DartComponentSupplier
+!set outputformat mysql
+
+select dim1 from foo ;
++------+
+| dim1 |
++------+
+|      |
+| 1    |
+| 10.1 |
+| 2    |
+| abc  |
+| def  |
++------+
+(6 rows)
+
+!ok
+
+select dim1 from foo ;
++------+
+| dim1 |
++------+
+|      |
+| 1    |
+| 10.1 |
+| 2    |
+| abc  |
+| def  |
++------+
+(6 rows)
+
+!ok
+
+select dim2,count(dim3) from foo group by dim2;
++------+--------+
+| dim2 | EXPR$1 |
++------+--------+
+|      |      1 |
+| a    |      2 |
+| abc  |      0 |
+|      |      1 |
++------+--------+
+(4 rows)
+
+!ok
diff --git a/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaTestDriver.java b/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaTestDriver.java
index ce575b52356f..21e0cc7bd71a 100644
--- a/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaTestDriver.java
+++ b/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaTestDriver.java
@@ -24,7 +24,6 @@
 import com.google.inject.Injector;
 import com.google.inject.Provides;
 import com.google.inject.name.Named;
-import com.google.inject.name.Names;
 import org.apache.calcite.avatica.server.AbstractAvaticaHandler;
 import org.apache.druid.guice.LazySingleton;
 import org.apache.druid.initialization.DruidModule;
@@ -199,19 +198,6 @@ public AvaticaBasedTestConnectionSupplier(QueryComponentSupplier delegate)
       this.connectionModule = new AvaticaBasedConnectionModule();
     }
 
-    @Override
-    public DruidModule getCoreModule()
-    {
-      return DruidModuleCollection.of(
-          super.getCoreModule(),
-          binder -> {
-            binder.bindConstant().annotatedWith(Names.named("serviceName")).to("test");
-            binder.bindConstant().annotatedWith(Names.named("servicePort")).to(0);
-            binder.bindConstant().annotatedWith(Names.named("tlsServicePort")).to(-1);
-          }
-      );
-    }
-
     @Override
     public DruidModule getOverrideModule()
     {
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/QueryTestBuilder.java b/sql/src/test/java/org/apache/druid/sql/calcite/QueryTestBuilder.java
index f53b2f37b1f5..c35003e0e767 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/QueryTestBuilder.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/QueryTestBuilder.java
@@ -163,9 +163,7 @@ public QueryTestBuilder expectedQueries(List<Query<?>> expectedQueries)
     return this;
   }
 
-  public QueryTestBuilder expectedResults(
-      final List<Object[]> expectedResults
-  )
+  public QueryTestBuilder expectedResults(final List<Object[]> expectedResults)
   {
     return expectedResults(ResultMatchMode.EQUALS, expectedResults);
   }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/CalciteTests.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/CalciteTests.java
index abf32c9bf321..cb3ceaf442d7 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/util/CalciteTests.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/CalciteTests.java
@@ -32,6 +32,7 @@
 import org.apache.druid.client.FilteredServerInventoryView;
 import org.apache.druid.client.ServerInventoryView;
 import org.apache.druid.client.ServerView;
+import org.apache.druid.client.TimelineServerView;
 import org.apache.druid.discovery.DiscoveryDruidNode;
 import org.apache.druid.discovery.DruidLeaderClient;
 import org.apache.druid.discovery.DruidNodeDiscovery;
@@ -397,7 +398,7 @@ NodeRole.COORDINATOR, new FakeDruidNodeDiscovery(ImmutableMap.of(NodeRole.COORDI
 
   public static SystemSchema createMockSystemSchema(
       final DruidSchema druidSchema,
-      final SpecificSegmentsQuerySegmentWalker walker,
+      final TimelineServerView timelineServerView,
       final AuthorizerMapper authorizerMapper
   )
   {
@@ -474,7 +475,7 @@ private TaskStatusPlus createTaskStatus(String id, String datasource, Long durat
             new BrokerSegmentWatcherConfig(),
             BrokerSegmentMetadataCacheConfig.create()
         ),
-        new TestTimelineServerView(walker.getSegments()),
+        timelineServerView,
         new FakeServerInventoryView(),
         authorizerMapper,
         druidLeaderClient,
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/QueryFrameworkUtils.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/QueryFrameworkUtils.java
index f28461e1711c..f61f52343987 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/util/QueryFrameworkUtils.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/QueryFrameworkUtils.java
@@ -26,6 +26,7 @@
 import org.apache.calcite.jdbc.CalciteSchema;
 import org.apache.calcite.schema.SchemaPlus;
 import org.apache.druid.client.InternalQueryConfig;
+import org.apache.druid.client.TimelineServerView;
 import org.apache.druid.java.util.emitter.core.NoopEmitter;
 import org.apache.druid.java.util.emitter.service.ServiceEmitter;
 import org.apache.druid.query.DefaultGenericQueryMetricsFactory;
@@ -125,7 +126,32 @@ public static DruidSchemaCatalog createMockRootSchema(
       @Nullable final ViewManager viewManager,
       final DruidSchemaManager druidSchemaManager,
       final AuthorizerMapper authorizerMapper,
-      final CatalogResolver catalogResolver
+      final CatalogResolver catalogResolver)
+  {
+    TimelineServerView timelineServerView = new TestTimelineServerView(walker.getSegments());
+    return createMockRootSchema(
+        injector,
+        conglomerate,
+        walker,
+        plannerConfig,
+        viewManager,
+        druidSchemaManager,
+        authorizerMapper,
+        catalogResolver,
+        timelineServerView
+    );
+  }
+
+  public static DruidSchemaCatalog createMockRootSchema(
+      final Injector injector,
+      final QueryRunnerFactoryConglomerate conglomerate,
+      final SpecificSegmentsQuerySegmentWalker walker,
+      final PlannerConfig plannerConfig,
+      @Nullable final ViewManager viewManager,
+      final DruidSchemaManager druidSchemaManager,
+      final AuthorizerMapper authorizerMapper,
+      final CatalogResolver catalogResolver,
+      final TimelineServerView timelineServerView
   )
   {
     DruidSchema druidSchema = createMockSchema(
@@ -133,10 +159,11 @@ public static DruidSchemaCatalog createMockRootSchema(
         conglomerate,
         walker,
         druidSchemaManager,
-        catalogResolver
+        catalogResolver,
+        timelineServerView
     );
     SystemSchema systemSchema =
-        CalciteTests.createMockSystemSchema(druidSchema, walker, authorizerMapper);
+        CalciteTests.createMockSystemSchema(druidSchema, timelineServerView, authorizerMapper);
 
     LookupSchema lookupSchema = createMockLookupSchema(injector);
     DruidOperatorTable createOperatorTable = createOperatorTable(injector);
@@ -221,12 +248,13 @@ static DruidSchema createMockSchema(
       final QueryRunnerFactoryConglomerate conglomerate,
       final SpecificSegmentsQuerySegmentWalker walker,
       final DruidSchemaManager druidSchemaManager,
-      final CatalogResolver catalog
+      final CatalogResolver catalog,
+      final TimelineServerView timelineServerView
   )
   {
     final BrokerSegmentMetadataCache cache = new BrokerSegmentMetadataCache(
         createMockQueryLifecycleFactory(walker, conglomerate),
-        new TestTimelineServerView(walker.getSegments()),
+        timelineServerView,
         BrokerSegmentMetadataCacheConfig.create(),
         CalciteTests.TEST_AUTHENTICATOR_ESCALATOR,
         new InternalQueryConfig(),
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
index 90cc53d1b9a0..d88af75df644 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
@@ -29,8 +29,11 @@
 import com.google.inject.Module;
 import com.google.inject.Provides;
 import com.google.inject.TypeLiteral;
+import org.apache.druid.client.TestHttpClient;
+import org.apache.druid.client.TimelineServerView;
 import org.apache.druid.client.cache.Cache;
 import org.apache.druid.client.cache.CacheConfig;
+import org.apache.druid.collections.BlockingPool;
 import org.apache.druid.collections.NonBlockingPool;
 import org.apache.druid.guice.BuiltInTypesModule;
 import org.apache.druid.guice.DruidInjectorBuilder;
@@ -44,12 +47,14 @@
 import org.apache.druid.guice.StartupInjectorBuilder;
 import org.apache.druid.guice.annotations.Global;
 import org.apache.druid.guice.annotations.Merging;
+import org.apache.druid.guice.annotations.Self;
 import org.apache.druid.initialization.CoreInjectorBuilder;
 import org.apache.druid.initialization.DruidModule;
 import org.apache.druid.initialization.ServiceInjectorBuilder;
 import org.apache.druid.java.util.common.RE;
 import org.apache.druid.java.util.common.io.Closer;
 import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.java.util.http.client.HttpClient;
 import org.apache.druid.math.expr.ExprMacroTable;
 import org.apache.druid.query.DefaultGenericQueryMetricsFactory;
 import org.apache.druid.query.DruidProcessingConfig;
@@ -78,6 +83,7 @@
 import org.apache.druid.segment.realtime.ChatHandlerProvider;
 import org.apache.druid.segment.realtime.NoopChatHandlerProvider;
 import org.apache.druid.server.ClientQuerySegmentWalker;
+import org.apache.druid.server.DruidNode;
 import org.apache.druid.server.LocalQuerySegmentWalker;
 import org.apache.druid.server.QueryLifecycle;
 import org.apache.druid.server.QueryLifecycleFactory;
@@ -672,7 +678,8 @@ public PlannerFixture(
           viewManager,
           componentSupplier.createSchemaManager(),
           framework.authorizerMapper,
-          framework.builder.catalogResolver
+          framework.builder.catalogResolver,
+          framework.injector.getInstance(TimelineServerView.class)
       );
 
       this.plannerFactory = new PlannerFactory(
@@ -771,10 +778,22 @@ public void configure(Binder binder)
             .annotatedWith(Global.class)
             .to(TestBufferPool.class);
 
+      binder.bind(new TypeLiteral<BlockingPool<ByteBuffer>>(){})
+            .annotatedWith(Merging.class)
+            .to(TestBufferPool.class);
+
       TestRequestLogger testRequestLogger = new TestRequestLogger();
       binder.bind(RequestLogger.class).toInstance(testRequestLogger);
     }
 
+    @Provides
+    @Self
+    @LazySingleton
+    public DruidNode makeSelfDruidNode()
+    {
+      return new DruidNode("druid/broker", "local-test-host", false, 12345, 443, true, false);
+    }
+
     @Provides
     AuthorizerMapper getAuthorizerMapper()
     {
@@ -923,26 +942,36 @@ private DruidSchema makeDruidSchema(
         final Injector injector,
         QueryRunnerFactoryConglomerate conglomerate,
         QuerySegmentWalker walker,
-        Builder builder)
+        Builder builder,
+        TimelineServerView timelineServerView)
     {
       return QueryFrameworkUtils.createMockSchema(
           injector,
           conglomerate,
           (SpecificSegmentsQuerySegmentWalker) walker,
           builder.componentSupplier.getPlannerComponentSupplier().createSchemaManager(),
-          builder.catalogResolver
+          builder.catalogResolver,
+          timelineServerView
       );
     }
 
     @Provides
     @LazySingleton
-    private SystemSchema makeSystemSchema(QuerySegmentWalker walker, AuthorizerMapper authorizerMapper,
-        DruidSchema druidSchema)
+    private SystemSchema makeSystemSchema(AuthorizerMapper authorizerMapper, DruidSchema druidSchema,
+        TimelineServerView timelineServerView)
+    {
+      return CalciteTests.createMockSystemSchema(druidSchema, timelineServerView, authorizerMapper);
+    }
+
+
+    @Provides
+    @LazySingleton
+    private TimelineServerView makeTimelineServerView(SpecificSegmentsQuerySegmentWalker walker)
     {
-      return CalciteTests
-          .createMockSystemSchema(druidSchema, (SpecificSegmentsQuerySegmentWalker) walker, authorizerMapper);
+      return new TestTimelineServerView(walker.getSegments());
     }
 
+
     @Provides
     @LazySingleton
     private ColumnConfig getColumnConfig()
@@ -1039,6 +1068,13 @@ public TestSegmentsBroker makeTimelines()
       return new TestSegmentsBroker();
     }
 
+    @Provides
+    @LazySingleton
+    private HttpClient makeHttpClient(ObjectMapper objectMapper)
+    {
+      return new TestHttpClient(objectMapper);
+    }
+
     @Provides
     @Named("empty")
     @LazySingleton
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/TestTimelineServerView.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/TestTimelineServerView.java
index 42aa4e491cb4..88df3b80a4e5 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/util/TestTimelineServerView.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/TestTimelineServerView.java
@@ -25,7 +25,10 @@
 import org.apache.druid.client.ImmutableDruidDataSource;
 import org.apache.druid.client.ImmutableDruidServer;
 import org.apache.druid.client.TimelineServerView;
+import org.apache.druid.client.selector.HighestPriorityTierSelectorStrategy;
+import org.apache.druid.client.selector.RandomServerSelectorStrategy;
 import org.apache.druid.client.selector.ServerSelector;
+import org.apache.druid.client.selector.TierSelectorStrategy;
 import org.apache.druid.java.util.common.Pair;
 import org.apache.druid.query.QueryRunner;
 import org.apache.druid.query.TableDataSource;
@@ -33,9 +36,12 @@
 import org.apache.druid.server.coordination.ServerType;
 import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.TimelineLookup;
-
+import org.apache.druid.timeline.VersionedIntervalTimeline;
+import org.apache.druid.timeline.partition.PartitionChunk;
+import org.apache.druid.timeline.partition.SingleElementPartitionChunk;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.Executor;
@@ -47,7 +53,7 @@ public class TestTimelineServerView implements TimelineServerView
 {
   private static final DruidServerMetadata DUMMY_SERVER = new DruidServerMetadata(
       "dummy",
-      "dummy",
+      "dummy:15723",
       null,
       0,
       ServerType.HISTORICAL,
@@ -56,7 +62,7 @@ public class TestTimelineServerView implements TimelineServerView
   );
   private static final DruidServerMetadata DUMMY_SERVER_REALTIME = new DruidServerMetadata(
       "dummy2",
-      "dummy2",
+      "dummy2:15723",
       null,
       0,
       ServerType.REALTIME,
@@ -65,7 +71,7 @@ public class TestTimelineServerView implements TimelineServerView
   );
   private static final DruidServerMetadata DUMMY_BROKER = new DruidServerMetadata(
       "dummy3",
-      "dummy3",
+      "dummy3:15723",
       null,
       0,
       ServerType.BROKER,
@@ -81,7 +87,7 @@ public class TestTimelineServerView implements TimelineServerView
 
   public TestTimelineServerView(List<DataSegment> segments)
   {
-    this.segments.addAll(segments);
+    this(segments, Collections.emptyList());
   }
 
   public TestTimelineServerView(List<DataSegment> segments, List<DataSegment> realtimeSegments)
@@ -93,7 +99,22 @@ public TestTimelineServerView(List<DataSegment> segments, List<DataSegment> real
   @Override
   public Optional<? extends TimelineLookup<String, ServerSelector>> getTimeline(TableDataSource table)
   {
-    throw new UnsupportedOperationException();
+    for (DataSegment segment : segments) {
+      if (!segment.getDataSource().equals(table.getName())) {
+        continue;
+      }
+
+      VersionedIntervalTimeline<String, ServerSelector> timelineLookup = new VersionedIntervalTimeline<String, ServerSelector>(
+          Comparator.naturalOrder()
+      );
+      TierSelectorStrategy st = new HighestPriorityTierSelectorStrategy(new RandomServerSelectorStrategy());
+      ServerSelector sss = new ServerSelector(segment, st);
+
+      PartitionChunk<ServerSelector> partitionChunk = new SingleElementPartitionChunk(sss);
+      timelineLookup.add(segment.getInterval(), segment.getVersion(), partitionChunk);
+      return Optional.of(timelineLookup);
+    }
+    return Optional.empty();
   }
 
   @Override

From f6fbfce3621ef1ff620096134fda220d16e27ed3 Mon Sep 17 00:00:00 2001
From: Virushade <70288012+GWphua@users.noreply.github.com>
Date: Mon, 17 Mar 2025 20:55:14 +0800
Subject: [PATCH 34/99] Fix single container config creates failing peon tasks
 (#17794)

* Fix single container config creates failing peon tasks

* More obvious array error output
---
 distribution/docker/peon.sh                              | 6 +++++-
 services/src/main/java/org/apache/druid/cli/CliPeon.java | 7 +++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/distribution/docker/peon.sh b/distribution/docker/peon.sh
index 3b4dfc4326b9..444aec94e9a2 100755
--- a/distribution/docker/peon.sh
+++ b/distribution/docker/peon.sh
@@ -161,4 +161,8 @@ fi
 # If TASK_JSON is not set, CliPeon will pull the task.json file from deep storage.
 mkdir -p ${TASK_DIR}; [ -n "$TASK_JSON" ] && echo ${TASK_JSON} | base64 -d | gzip -d > ${TASK_DIR}/task.json;
 
-exec bin/run-java ${JAVA_OPTS} -cp $COMMON_CONF_DIR:$SERVICE_CONF_DIR:lib/*: org.apache.druid.cli.Main internal peon --taskId ${TASK_ID} $@
+if [ -n "$TASK_ID" ]; then
+    exec bin/run-java ${JAVA_OPTS} -cp $COMMON_CONF_DIR:$SERVICE_CONF_DIR:lib/*: org.apache.druid.cli.Main internal peon --taskId "${TASK_ID}" "$@"
+else
+    exec bin/run-java ${JAVA_OPTS} -cp $COMMON_CONF_DIR:$SERVICE_CONF_DIR:lib/*: org.apache.druid.cli.Main internal peon "$@"
+fi
diff --git a/services/src/main/java/org/apache/druid/cli/CliPeon.java b/services/src/main/java/org/apache/druid/cli/CliPeon.java
index 307ba269a4f4..3d06ad7dee3e 100644
--- a/services/src/main/java/org/apache/druid/cli/CliPeon.java
+++ b/services/src/main/java/org/apache/druid/cli/CliPeon.java
@@ -24,6 +24,7 @@
 import com.github.rvesse.airline.annotations.Command;
 import com.github.rvesse.airline.annotations.Option;
 import com.github.rvesse.airline.annotations.restrictions.Required;
+import com.google.common.base.Preconditions;
 import com.google.common.base.Supplier;
 import com.google.common.base.Throwables;
 import com.google.common.collect.ImmutableList;
@@ -234,6 +235,12 @@ protected List<? extends Module> getModules()
           public void configure(Binder binder)
           {
             ServerRunnable.validateCentralizedDatasourceSchemaConfig(getProperties());
+            Preconditions.checkArgument(
+                taskAndStatusFile.size() >= 2,
+                "taskAndStatusFile array should contain 2 or more elements. Current array elements: [%s]",
+                taskAndStatusFile.toString()
+            );
+
             taskDirPath = taskAndStatusFile.get(0);
             attemptId = taskAndStatusFile.get(1);
 

From f4440b5f34bf967c0f877626db066b7dc42426a1 Mon Sep 17 00:00:00 2001
From: Emmanuel Ferdman <emmanuelferdman@gmail.com>
Date: Mon, 17 Mar 2025 16:55:26 +0400
Subject: [PATCH 35/99] Update `k8s-jobs.md` reference (#17805)

Signed-off-by: Emmanuel Ferdman <emmanuelferdman@gmail.com>
---
 extensions-core/kubernetes-overlord-extensions/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/extensions-core/kubernetes-overlord-extensions/README.md b/extensions-core/kubernetes-overlord-extensions/README.md
index 7ebc704ecb73..d94a46966cbb 100644
--- a/extensions-core/kubernetes-overlord-extensions/README.md
+++ b/extensions-core/kubernetes-overlord-extensions/README.md
@@ -27,6 +27,6 @@ its tasks as Kubernetes Jobs instead of sending them to workers (middle managers
 
 Documentation
 =============
-More detailed documentation about how to configure and use the extension is available [here](../../docs/development/extensions-contrib/k8s-jobs.md)
+More detailed documentation about how to configure and use the extension is available [here](../../docs/development/extensions-core/k8s-jobs.md)
 
 

From adb076d9004726938bc93c13299b46ce9b807caa Mon Sep 17 00:00:00 2001
From: Om Kenge <88768848+omkenge@users.noreply.github.com>
Date: Mon, 17 Mar 2025 18:27:24 +0530
Subject: [PATCH 36/99] Footer Copyright Year Update (#17751)

* Update docusaurus.config.js

* Update docusaurus.config.js
---
 website/docusaurus.config.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/website/docusaurus.config.js b/website/docusaurus.config.js
index 7ebaa7cc73e0..720cb3d8523d 100644
--- a/website/docusaurus.config.js
+++ b/website/docusaurus.config.js
@@ -158,10 +158,10 @@ module.exports={
     "image": "img/druid_nav.png",
     "footer": {
       "links": [],
-      "copyright": "Copyright © 2023 Apache Software Foundation",
+      "copyright": "Copyright © 2025 Apache Software Foundation",
       "logo": {
         "src": "img/favicon.png"
       }
     },
   }
-}
\ No newline at end of file
+}

From 00b85425d04cf50943f8e3e7d51282dd6ba28818 Mon Sep 17 00:00:00 2001
From: Kashif Faraz <kashif.faraz@gmail.com>
Date: Mon, 17 Mar 2025 20:18:44 +0530
Subject: [PATCH 37/99] [Revert] Reduce number of metadata transaction retries
 (#17808)

---
 .../supervisor/SeekableStreamSupervisor.java  |  2 +-
 .../druid/metadata/SQLMetadataConnector.java  | 24 +++++++++++++++----
 .../SQLMetadataStorageActionHandler.java      | 17 ++++---------
 .../SqlSegmentMetadataTransactionFactory.java |  4 ++--
 .../cache/HeapMemorySegmentMetadataCache.java |  4 ++--
 5 files changed, 29 insertions(+), 22 deletions(-)

diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java b/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java
index 442dcc35f4c5..daaf2529cc49 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java
@@ -1010,7 +1010,7 @@ public void start()
                       0,
                       MAX_INITIALIZATION_RETRIES,
                       null,
-                      null
+                      StringUtils.format("Failed to initialize supervisor[%s]", supervisorId)
                   );
                 }
                 catch (Exception e2) {
diff --git a/server/src/main/java/org/apache/druid/metadata/SQLMetadataConnector.java b/server/src/main/java/org/apache/druid/metadata/SQLMetadataConnector.java
index b7fad1336577..b51739e4f35c 100644
--- a/server/src/main/java/org/apache/druid/metadata/SQLMetadataConnector.java
+++ b/server/src/main/java/org/apache/druid/metadata/SQLMetadataConnector.java
@@ -67,7 +67,8 @@ public abstract class SQLMetadataConnector implements MetadataStorageConnector
   private static final String PAYLOAD_TYPE = "BLOB";
   private static final String COLLATION = "";
 
-  static final int DEFAULT_MAX_TRIES = 10;
+  static final int QUIET_RETRIES = 2;
+  static final int DEFAULT_MAX_TRIES = 3;
 
   private final Supplier<MetadataStorageConnectorConfig> config;
   private final Supplier<MetadataStorageTablesConfig> tablesConfigSupplier;
@@ -154,7 +155,13 @@ public <T> T retryWithHandle(
   )
   {
     try {
-      return RetryUtils.retry(() -> getDBI().withHandle(callback), myShouldRetry, DEFAULT_MAX_TRIES);
+      return RetryUtils.retry(
+          () -> getDBI().withHandle(callback),
+          myShouldRetry,
+          null,
+          DEFAULT_MAX_TRIES,
+          "Metadata transaction failed"
+      );
     }
     catch (Exception e) {
       Throwables.propagateIfPossible(e);
@@ -170,7 +177,14 @@ public <T> T retryWithHandle(final HandleCallback<T> callback)
   public <T> T retryTransaction(final TransactionCallback<T> callback, final int quietTries, final int maxTries)
   {
     try {
-      return RetryUtils.retry(() -> getDBI().inTransaction(TransactionIsolationLevel.READ_COMMITTED, callback), shouldRetry, quietTries, maxTries);
+      return RetryUtils.retry(
+          () -> getDBI().inTransaction(TransactionIsolationLevel.READ_COMMITTED, callback),
+          shouldRetry,
+          quietTries,
+          maxTries,
+          null,
+          "Metadata write transaction failed"
+      );
     }
     catch (Exception e) {
       Throwables.propagateIfPossible(e);
@@ -897,7 +911,9 @@ public final <T> T retryReadOnlyTransaction(
           () -> getDBI().inTransaction(TransactionIsolationLevel.READ_COMMITTED, callback),
           shouldRetry,
           quietTries,
-          maxTries
+          maxTries,
+          null,
+          "Metadata read transaction failed"
       );
     }
     catch (Exception e) {
diff --git a/server/src/main/java/org/apache/druid/metadata/SQLMetadataStorageActionHandler.java b/server/src/main/java/org/apache/druid/metadata/SQLMetadataStorageActionHandler.java
index 910e2e1b1633..f8c506d71da9 100644
--- a/server/src/main/java/org/apache/druid/metadata/SQLMetadataStorageActionHandler.java
+++ b/server/src/main/java/org/apache/druid/metadata/SQLMetadataStorageActionHandler.java
@@ -377,7 +377,7 @@ public List<TaskInfo<EntryType, StatusType>> getTaskInfos(
           }
           return tasks;
         },
-        3,
+        SQLMetadataConnector.QUIET_RETRIES,
         SQLMetadataConnector.DEFAULT_MAX_TRIES
     );
   }
@@ -436,7 +436,7 @@ List<TaskInfo<TaskIdentifier, StatusType>> getTaskStatusList(
           }
           return taskMetadataInfos;
         },
-        3,
+        SQLMetadataConnector.QUIET_RETRIES,
         SQLMetadataConnector.DEFAULT_MAX_TRIES
     );
   }
@@ -840,7 +840,7 @@ public boolean replaceLock(final String entryId, final long oldLockId, final Loc
 
           return addLock(handle, entryId, newLock);
         },
-        3,
+        SQLMetadataConnector.QUIET_RETRIES,
         SQLMetadataConnector.DEFAULT_MAX_TRIES
     );
   }
@@ -849,16 +849,7 @@ public boolean replaceLock(final String entryId, final long oldLockId, final Loc
   public void removeLock(final long lockId)
   {
     connector.retryWithHandle(
-        new HandleCallback<Void>()
-        {
-          @Override
-          public Void withHandle(Handle handle)
-          {
-            removeLock(handle, lockId);
-
-            return null;
-          }
-        }
+        handle -> removeLock(handle, lockId)
     );
   }
 
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/SqlSegmentMetadataTransactionFactory.java b/server/src/main/java/org/apache/druid/metadata/segment/SqlSegmentMetadataTransactionFactory.java
index 612f888ff8ee..5a6adbdf8fff 100644
--- a/server/src/main/java/org/apache/druid/metadata/segment/SqlSegmentMetadataTransactionFactory.java
+++ b/server/src/main/java/org/apache/druid/metadata/segment/SqlSegmentMetadataTransactionFactory.java
@@ -40,8 +40,8 @@
  */
 public class SqlSegmentMetadataTransactionFactory implements SegmentMetadataTransactionFactory
 {
-  private static final int QUIET_RETRIES = 3;
-  private static final int MAX_RETRIES = 10;
+  private static final int QUIET_RETRIES = 2;
+  private static final int MAX_RETRIES = 3;
 
   private final ObjectMapper jsonMapper;
   private final MetadataStorageTablesConfig tablesConfig;
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCache.java b/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCache.java
index 65482e41046b..2d177509547b 100644
--- a/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCache.java
+++ b/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCache.java
@@ -73,8 +73,8 @@ public class HeapMemorySegmentMetadataCache implements SegmentMetadataCache
 {
   private static final EmittingLogger log = new EmittingLogger(HeapMemorySegmentMetadataCache.class);
 
-  private static final int SQL_MAX_RETRIES = 10;
-  private static final int SQL_QUIET_RETRIES = 3;
+  private static final int SQL_MAX_RETRIES = 3;
+  private static final int SQL_QUIET_RETRIES = 2;
 
   /**
    * Maximum time to wait for cache to be ready.

From 77aa3fcfcf04e78e28f2a5700e865c07e13e23aa Mon Sep 17 00:00:00 2001
From: Karan Kumar <karankumar1100@gmail.com>
Date: Tue, 18 Mar 2025 19:39:06 +0530
Subject: [PATCH 38/99] Revert "Run JDK 21 workflows with latest JDK. (#17694)"
 (#17806)

* Revert "Run JDK 21 workflows with latest JDK. (#17694)"

This reverts commit 31ede5cb

* Review comments.

* Review comments.
---
 .github/workflows/cron-job-unit-tests.yml                | 6 +++---
 .github/workflows/static-checks.yml                      | 3 ++-
 .github/workflows/unit-and-integration-tests-unified.yml | 3 ++-
 3 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/cron-job-unit-tests.yml b/.github/workflows/cron-job-unit-tests.yml
index 1b44bd5a424c..cb9f1117baba 100644
--- a/.github/workflows/cron-job-unit-tests.yml
+++ b/.github/workflows/cron-job-unit-tests.yml
@@ -29,7 +29,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        jdk: [ '11', '21' ]
+        jdk: [ '11', '21.0.4' ]
         Dtest: [ "A*,F*,S*", "B*,D*,L*,T*", "C*,O*", "E*,N*,Q*", "G*,R*,U*", "H*,I*,J*", "K*,P*,V*,W*,X*,Y*,Z*", "M*"]
     uses: ./.github/workflows/worker.yml
     with:
@@ -45,7 +45,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        jdk: [ '11', '21' ]
+        jdk: [ '11', '21.0.4' ]
     steps:
       - name: Download reports for all unit test jobs
         uses: actions/download-artifact@v4
@@ -72,7 +72,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        jdk: [ '11', '21' ]
+        jdk: [ '11', '21.0.4' ]
     with:
       script: .github/scripts/create-jacoco-coverage-report.sh
       artifacts_to_download: "unit-test-reports-${{ matrix.jdk }}-*"
diff --git a/.github/workflows/static-checks.yml b/.github/workflows/static-checks.yml
index 5f9fd7b4d608..6a149a46a6d3 100644
--- a/.github/workflows/static-checks.yml
+++ b/.github/workflows/static-checks.yml
@@ -41,7 +41,8 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        java: [ '11', '17', '21' ]
+        # Use JDK 21.0.4 to work around https://github.com/apache/druid/issues/17429
+        java: [ '11', '17', '21.0.4' ]
     runs-on: ubuntu-latest
     steps:
       - name: checkout branch
diff --git a/.github/workflows/unit-and-integration-tests-unified.yml b/.github/workflows/unit-and-integration-tests-unified.yml
index 1a5fdddff631..15eb29df604e 100644
--- a/.github/workflows/unit-and-integration-tests-unified.yml
+++ b/.github/workflows/unit-and-integration-tests-unified.yml
@@ -79,7 +79,8 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        jdk: [ '11', '17', '21' ]
+        # Use JDK 21.0.4 to work around https://github.com/apache/druid/issues/17429
+        jdk: [ '11', '17', '21.0.4' ]
     runs-on: ubuntu-latest
     steps:
       - name: Checkout branch

From ac692b371f54fc2904062aeb55c4b97431944c06 Mon Sep 17 00:00:00 2001
From: Kashif Faraz <kashif.faraz@gmail.com>
Date: Fri, 14 Mar 2025 09:53:38 +0530
Subject: [PATCH 39/99] Revert "reject publishing actions with a retriable
 error code if a earlier task is still publishing (#17509)"

This reverts commit aca56d6bb842231853d624e7da07748ba002ac4f.
---
 .../indexing/common/actions/LocalTaskActionClient.java      | 1 -
 .../actions/SegmentTransactionalInsertActionTest.java       | 4 ++--
 .../metadata/IndexerSQLMetadataStorageCoordinator.java      | 4 +---
 .../metadata/IndexerSQLMetadataStorageCoordinatorTest.java  | 6 +++---
 4 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/LocalTaskActionClient.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/LocalTaskActionClient.java
index 81ff137ed179..1d0059335ed1 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/LocalTaskActionClient.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/LocalTaskActionClient.java
@@ -69,7 +69,6 @@ private <R> R performAction(TaskAction<R> taskAction)
       return result;
     }
     catch (Throwable t) {
-      log.error(t, "Failed to perform action[%s]", taskAction);
       throw new RuntimeException(t);
     }
   }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentTransactionalInsertActionTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentTransactionalInsertActionTest.java
index 7d5f4488fea0..44ce60b5ceb2 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentTransactionalInsertActionTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentTransactionalInsertActionTest.java
@@ -22,6 +22,7 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
+import org.apache.druid.error.InvalidInput;
 import org.apache.druid.indexing.common.TaskLockType;
 import org.apache.druid.indexing.common.task.NoopTask;
 import org.apache.druid.indexing.common.task.Task;
@@ -31,7 +32,6 @@
 import org.apache.druid.indexing.overlord.Segments;
 import org.apache.druid.indexing.overlord.TimeChunkLockRequest;
 import org.apache.druid.java.util.common.Intervals;
-import org.apache.druid.metadata.RetryTransactionException;
 import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.partition.LinearShardSpec;
 import org.assertj.core.api.Assertions;
@@ -151,7 +151,7 @@ public void testFailTransactionalUpdateDataSourceMetadata() throws Exception
 
     Assert.assertEquals(
         SegmentPublishResult.fail(
-            new RetryTransactionException(
+            InvalidInput.exception(
                 "The new start metadata state[ObjectMetadata{theObject=[1]}] is"
                 + " ahead of the last committed end state[null]. Try resetting the supervisor."
             ).toString()
diff --git a/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java b/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java
index fcdd31d0fa6a..ce092f8c6967 100644
--- a/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java
+++ b/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java
@@ -2102,9 +2102,7 @@ protected DataStoreMetadataUpdateResult updateDataSourceMetadataWithHandle(
 
     if (startMetadataGreaterThanExisting && !startMetadataMatchesExisting) {
       // Offsets stored in startMetadata is greater than the last commited metadata.
-      // This can happen because the previous task is still publishing its segments and can resolve once
-      // the previous task finishes publishing.
-      return DataStoreMetadataUpdateResult.retryableFailure(
+      return DataStoreMetadataUpdateResult.failure(
           "The new start metadata state[%s] is ahead of the last committed"
           + " end state[%s]. Try resetting the supervisor.",
           startMetadata, oldCommitMetadataFromDb
diff --git a/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java b/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java
index 9a63c2d781c7..b6578fa9a721 100644
--- a/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java
+++ b/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java
@@ -858,15 +858,15 @@ public void testTransactionalAnnounceFailDbNullWantNotNull()
     );
     Assert.assertEquals(
         SegmentPublishResult.fail(
-            new RetryTransactionException(
+            InvalidInput.exception(
                 "The new start metadata state[ObjectMetadata{theObject={foo=bar}}] is ahead of the last committed"
                 + " end state[null]. Try resetting the supervisor."
             ).toString()),
         result1
     );
 
-    // Should be retried.
-    Assert.assertEquals(2, metadataUpdateCounter.get());
+    // Should only be tried once.
+    Assert.assertEquals(1, metadataUpdateCounter.get());
   }
 
   @Test

From b5a9196354fe5697531c8313c3cc5be5fa95844a Mon Sep 17 00:00:00 2001
From: Zoltan Haindrich <kirk@rxd.hu>
Date: Wed, 19 Mar 2025 09:46:04 +0100
Subject: [PATCH 40/99] Fix unstable tests after #17787 and dart usage in
 quidem-ut (#17814)

* fixes

* fix cleanup
---
 .../test/MSQTestOverlordServiceClient.java    |  2 +-
 .../druid/msq/test/MSQTestWorkerClient.java   |  1 -
 .../TestDartControllerContextFactoryImpl.java |  3 ++
 quidem-ut/pom.xml                             | 11 ++++-
 .../org.apache.druid.quidem.QTest/dart1.iq    | 46 +++++++++++++++++++
 5 files changed, 60 insertions(+), 3 deletions(-)
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/dart1.iq

diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestOverlordServiceClient.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestOverlordServiceClient.java
index 903ff1544c3f..3a034f147bed 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestOverlordServiceClient.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestOverlordServiceClient.java
@@ -137,7 +137,7 @@ public ListenableFuture<Void> runTask(String taskId, Object taskObject)
       throw new ISE(e, "Unable to run");
     }
     finally {
-      if (controller != null && queryListener != null) {
+      if (queryListener != null && queryListener.reportMap != null) {
         reports.put(controller.queryId(), queryListener.getReportMap());
       }
     }
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestWorkerClient.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestWorkerClient.java
index 9f482912f315..69741a9953cb 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestWorkerClient.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestWorkerClient.java
@@ -158,7 +158,6 @@ public void close()
   {
     if (closed.compareAndSet(false, true)) {
       inMemoryWorkers.forEach((k, v) -> v.stop());
-      inMemoryWorkers.clear();
     }
   }
 }
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/TestDartControllerContextFactoryImpl.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/TestDartControllerContextFactoryImpl.java
index 89209f012529..9a9aed874259 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/TestDartControllerContextFactoryImpl.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/TestDartControllerContextFactoryImpl.java
@@ -125,6 +125,9 @@ protected Worker newWorker(String workerId)
         catch (Exception e) {
           throw new RuntimeException(e);
         }
+        finally {
+          inMemoryWorkers.remove(workerId);
+        }
       });
 
       return worker;
diff --git a/quidem-ut/pom.xml b/quidem-ut/pom.xml
index f06fddf94622..6c7aab5c4279 100644
--- a/quidem-ut/pom.xml
+++ b/quidem-ut/pom.xml
@@ -424,7 +424,12 @@
             <type>test-jar</type>
             <version>${project.parent.version}</version>
         </dependency>
-
+        <dependency>
+            <groupId>org.apache.druid.extensions</groupId>
+            <artifactId>druid-multi-stage-query</artifactId>
+            <type>test-jar</type>
+            <version>${project.parent.version}</version>
+        </dependency>
         <dependency>
             <groupId>org.apache.druid.extensions</groupId>
             <artifactId>druid-datasketches</artifactId>
@@ -514,6 +519,10 @@
             <artifactId>hamcrest-core</artifactId>
             <scope>compile</scope>
         </dependency>
+	    <dependency>
+	      <groupId>org.mockito</groupId>
+	      <artifactId>mockito-core</artifactId>
+	    </dependency>
     </dependencies>
 
     <build>
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/dart1.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/dart1.iq
new file mode 100644
index 000000000000..b8a8415e4f88
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/dart1.iq
@@ -0,0 +1,46 @@
+!set dartQueryId 00000000-0000-0000-0000-000000000000
+!use druidtest://?componentSupplier=DartComponentSupplier
+!set outputformat mysql
+
+select * from numfoo;
++-------------------------+------+------+-----------+------+------+------+------+------+-----+-----+--------+--------+-----+-----+-----+--------------------+
+| __time                  | dim1 | dim2 | dim3      | dim4 | dim5 | dim6 | dbl1 | dbl2 | f1  | f2  | l1     | l2     | cnt | m1  | m2  | unique_dim1        |
++-------------------------+------+------+-----------+------+------+------+------+------+-----+-----+--------+--------+-----+-----+-----+--------------------+
+| 2000-01-01 00:00:00.000 |      | a    | ["a","b"] | a    | aa   | 1    |  1.0 |      | 1.0 |     |      7 |        |   1 | 1.0 | 1.0 | "AQAAAEAAAA=="     |
+| 2000-01-02 00:00:00.000 | 10.1 |      | ["b","c"] | a    | ab   | 2    |  1.7 |  1.7 | 0.1 | 0.1 | 325323 | 325323 |   1 | 2.0 | 2.0 | "AQAAAQAAAAHNBA==" |
+| 2001-01-01 00:00:00.000 | 1    | a    |           | b    | ad   | 4    |      |      |     |     |        |        |   1 | 4.0 | 4.0 | "AQAAAQAAAAFREA==" |
+| 2001-01-02 00:00:00.000 | def  | abc  |           | b    | aa   | 5    |      |      |     |     |        |        |   1 | 5.0 | 5.0 | "AQAAAQAAAACyEA==" |
+| 2001-01-03 00:00:00.000 | abc  |      |           | b    | ab   | 6    |      |      |     |     |        |        |   1 | 6.0 | 6.0 | "AQAAAQAAAAEkAQ==" |
+| 2000-01-03 00:00:00.000 | 2    |      | d         | a    | ba   | 3    |  0.0 |  0.0 | 0.0 | 0.0 |      0 |      0 |   1 | 3.0 | 3.0 | "AQAAAQAAAAOzAg==" |
++-------------------------+------+------+-----------+------+------+------+------+------+-----+-----+--------+--------+-----+-----+-----+--------------------+
+(6 rows)
+
+!ok
+select * from numfoo;
++-------------------------+------+------+-----------+------+------+------+------+------+-----+-----+--------+--------+-----+-----+-----+--------------------+
+| __time                  | dim1 | dim2 | dim3      | dim4 | dim5 | dim6 | dbl1 | dbl2 | f1  | f2  | l1     | l2     | cnt | m1  | m2  | unique_dim1        |
++-------------------------+------+------+-----------+------+------+------+------+------+-----+-----+--------+--------+-----+-----+-----+--------------------+
+| 2000-01-01 00:00:00.000 |      | a    | ["a","b"] | a    | aa   | 1    |  1.0 |      | 1.0 |     |      7 |        |   1 | 1.0 | 1.0 | "AQAAAEAAAA=="     |
+| 2000-01-02 00:00:00.000 | 10.1 |      | ["b","c"] | a    | ab   | 2    |  1.7 |  1.7 | 0.1 | 0.1 | 325323 | 325323 |   1 | 2.0 | 2.0 | "AQAAAQAAAAHNBA==" |
+| 2000-01-03 00:00:00.000 | 2    |      | d         | a    | ba   | 3    |  0.0 |  0.0 | 0.0 | 0.0 |      0 |      0 |   1 | 3.0 | 3.0 | "AQAAAQAAAAOzAg==" |
+| 2001-01-01 00:00:00.000 | 1    | a    |           | b    | ad   | 4    |      |      |     |     |        |        |   1 | 4.0 | 4.0 | "AQAAAQAAAAFREA==" |
+| 2001-01-02 00:00:00.000 | def  | abc  |           | b    | aa   | 5    |      |      |     |     |        |        |   1 | 5.0 | 5.0 | "AQAAAQAAAACyEA==" |
+| 2001-01-03 00:00:00.000 | abc  |      |           | b    | ab   | 6    |      |      |     |     |        |        |   1 | 6.0 | 6.0 | "AQAAAQAAAAEkAQ==" |
++-------------------------+------+------+-----------+------+------+------+------+------+-----+-----+--------+--------+-----+-----+-----+--------------------+
+(6 rows)
+
+!ok
+select length(dim1) from numfoo;
++--------+
+| EXPR$0 |
++--------+
+|      0 |
+|      1 |
+|      1 |
+|      3 |
+|      3 |
+|      4 |
++--------+
+(6 rows)
+
+!ok

From 4bb279f25bc8b7b4e94d2f77c93a198df685c230 Mon Sep 17 00:00:00 2001
From: Gian Merlino <gianmerlino@gmail.com>
Date: Wed, 19 Mar 2025 01:46:42 -0700
Subject: [PATCH 41/99] Use "mix" shuffle spec for target size with nil
 clusterBy. (#17810)

When a nil clusterBy is used, we have no way of achieving a particular
target size, so we need to fall back to a "mix" spec (unsorted single
partition).

This comes up for queries like "SELECT COUNT(*) FROM FOO LIMIT 1" when
results use a target size, such as when we are inserting into another
table or when we are writing to durable storage.
---
 .../msq/querykit/ShuffleSpecFactories.java    | 17 ++++++++--
 .../apache/druid/msq/exec/MSQInsertTest.java  | 32 +++++++++++++++++++
 2 files changed, 46 insertions(+), 3 deletions(-)

diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/ShuffleSpecFactories.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/ShuffleSpecFactories.java
index 8f5770378c55..24f6dfffe27a 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/ShuffleSpecFactories.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/ShuffleSpecFactories.java
@@ -19,6 +19,7 @@
 
 package org.apache.druid.msq.querykit;
 
+import org.apache.druid.frame.key.ClusterBy;
 import org.apache.druid.msq.kernel.GlobalSortMaxCountShuffleSpec;
 import org.apache.druid.msq.kernel.GlobalSortTargetSizeShuffleSpec;
 import org.apache.druid.msq.kernel.MixShuffleSpec;
@@ -69,11 +70,21 @@ public static ShuffleSpecFactory globalSortWithMaxPartitionCount(final int parti
   }
 
   /**
-   * Factory that produces globally sorted partitions of a target size.
+   * Factory that produces globally sorted partitions of a target size, using the {@link ClusterBy} to partition
+   * rows across partitions.
+   *
+   * Produces {@link MixShuffleSpec}, ignoring the target size, if the provided {@link ClusterBy} is empty.
    */
   public static ShuffleSpecFactory getGlobalSortWithTargetSize(int targetSize)
   {
-    return (clusterBy, aggregate) ->
-        new GlobalSortTargetSizeShuffleSpec(clusterBy, targetSize, aggregate);
+    return (clusterBy, aggregate) -> {
+      if (clusterBy.isEmpty()) {
+        // Cannot partition or sort meaningfully because there are no cluster-by keys. Generate a MixShuffleSpec
+        // so everything goes into a single partition.
+        return MixShuffleSpec.instance();
+      } else {
+        return new GlobalSortTargetSizeShuffleSpec(clusterBy, targetSize, aggregate);
+      }
+    };
   }
 }
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/MSQInsertTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/MSQInsertTest.java
index 801faac44aff..6662f23d9b1c 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/MSQInsertTest.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/MSQInsertTest.java
@@ -1606,6 +1606,38 @@ public void testInsertOnFoo1WithLimit(String contextName, Map<String, Object> co
                      .verifyResults();
   }
 
+  @MethodSource("data")
+  @ParameterizedTest(name = "{index}:with context {0}")
+  public void testInsertOnFoo1NoDimensionsWithLimit(String contextName, Map<String, Object> context)
+  {
+    Map<String, Object> queryContext = ImmutableMap.<String, Object>builder()
+                                                   .putAll(context)
+                                                   .put(MultiStageQueryContext.CTX_ROWS_PER_SEGMENT, 2)
+                                                   .build();
+
+    List<Object[]> expectedRows = ImmutableList.of(new Object[]{DateTimes.utc(0L).getMillis(), 5L});
+
+    RowSignature rowSignature = RowSignature.builder()
+                                            .addTimeColumn()
+                                            .add("cnt", ColumnType.LONG)
+                                            .build();
+
+    testIngestQuery()
+        .setSql("insert into foo1 select count(*) cnt from foo where dim1 != '' limit 4 partitioned by all")
+        .setExpectedDataSource("foo1")
+        .setQueryContext(queryContext)
+        .setExpectedRowSignature(rowSignature)
+        .setExpectedSegments(ImmutableSet.of(SegmentId.of("foo1", Intervals.ETERNITY, "test", 0)))
+        .setExpectedResultRows(expectedRows)
+        .setExpectedMSQSegmentReport(
+            new MSQSegmentReport(
+                NumberedShardSpec.class.getSimpleName(),
+                "Using NumberedShardSpec to generate segments since the query is inserting rows."
+            )
+        )
+        .verifyResults();
+  }
+
   @MethodSource("data")
   @ParameterizedTest(name = "{index}:with context {0}")
   public void testInsertOnRestricted(String contextName, Map<String, Object> context)

From e4e123d0009d5e626cba9be3bbfc89a63f49cf7f Mon Sep 17 00:00:00 2001
From: Lars Francke <lars.francke@stackable.tech>
Date: Wed, 19 Mar 2025 11:04:40 +0100
Subject: [PATCH 42/99] Docs: Recommend using runtime property javaOptsArray
 instead of javaOpts

---
 dev/intellij-setup.md                  | 2 +-
 docs/development/extensions-core/s3.md | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/dev/intellij-setup.md b/dev/intellij-setup.md
index c08375a33472..108ec25c430b 100644
--- a/dev/intellij-setup.md
+++ b/dev/intellij-setup.md
@@ -74,7 +74,7 @@ Intellij IDEA debugger can attach to a local or remote Java process (Druid proce
 Follow these steps to debug a Druid process using the IntelliJ IDEA debugger.
 1. Enable debugging in the Druid process
     1. For Druid services (such as Overlord, Coordinator, etc), include the following as JVM config `-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=<PORT>` where `<PORT>` is any available port. Note that different port values should be chosen for each Druid service.
-    2. For the peons (workers on Middlemanager), include the following `agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=0` in runtime properties `druid.indexer.runner.javaOpts` of the Middle Manager. Note that `address=0` will tell the debugger to assign ephemeral port.
+    2. For the peons (workers on Middlemanager), add the string `"-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=0"` to the runtime property `druid.indexer.runner.javaOptsArray` of the Middle Manager. Note that `address=0` will tell the debugger to assign an ephemeral port.
 2. Find the port assigned to the Druid process.
     1. For Druid services, the port value is what you chose in the JVM argument of step 1i above. The port value can also be found in the first line of each Druid service log.
     2. For the peons (workers on Middlemanager), you can find the assigned ephemeral port by checking the first line of the task log.
diff --git a/docs/development/extensions-core/s3.md b/docs/development/extensions-core/s3.md
index 2565451c2725..93c4c122f775 100644
--- a/docs/development/extensions-core/s3.md
+++ b/docs/development/extensions-core/s3.md
@@ -117,7 +117,7 @@ The AWS SDK requires that a target region be specified.  You can set these by us
 For example, to set the region to 'us-east-1' through system properties:
 
 * Add `-Daws.region=us-east-1` to the `jvm.config` file for all Druid services.
-* Add `-Daws.region=us-east-1` to `druid.indexer.runner.javaOpts` in [Middle Manager configuration](../../configuration/index.md#middle-manager-configuration) so that the property will be passed to Peon (worker) processes.
+* Add `"-Daws.region=us-east-1"` to `druid.indexer.runner.javaOptsArray` in [Middle Manager configuration](../../configuration/index.md#middle-manager-configuration) so that the property will be passed to Peon (worker) processes.
 
 ### Connecting to S3 configuration
 

From d87550e134f7b3d93a4a6e08707b7bb7b9a0d37b Mon Sep 17 00:00:00 2001
From: Adarsh Sanjeev <adarshsanjeev@gmail.com>
Date: Wed, 19 Mar 2025 18:01:26 +0530
Subject: [PATCH 43/99] Add minor checks in jetty utils (#17817)

Add minor checks in jetty utils class
---
 .../org/apache/druid/server/JettyUtils.java   | 10 ++++++-
 .../AsyncManagementForwardingServletTest.java | 28 +++++++++++++++++--
 .../apache/druid/server/JettyUtilsTest.java   | 24 ++++++++++++++++
 3 files changed, 59 insertions(+), 3 deletions(-)

diff --git a/server/src/main/java/org/apache/druid/server/JettyUtils.java b/server/src/main/java/org/apache/druid/server/JettyUtils.java
index 717eb136b43a..0f503ef3b2fc 100644
--- a/server/src/main/java/org/apache/druid/server/JettyUtils.java
+++ b/server/src/main/java/org/apache/druid/server/JettyUtils.java
@@ -33,9 +33,13 @@ public class JettyUtils
    * Concatenate URI parts, in a way that is useful for proxy servlets.
    *
    * @param base               base part of the uri, like http://example.com (no trailing slash)
-   * @param encodedPath        encoded path, like you would get from HttpServletRequest's getRequestURI
+   * @param encodedPath        encoded path, like you would get from HttpServletRequest's getRequestURI. Must start with
+   *                           a slash.
    * @param encodedQueryString encoded query string, like you would get from HttpServletRequest's getQueryString
+   *
+   * @return rewritten target URI, or null if the URI cannot be rewritten
    */
+  @Nullable
   public static String concatenateForRewrite(
       final String base,
       final String encodedPath,
@@ -44,6 +48,10 @@ public static String concatenateForRewrite(
   {
     // Query string and path are already encoded, no need for anything fancy beyond string concatenation.
 
+    if (!encodedPath.startsWith("/")) {
+      return null;
+    }
+
     final StringBuilder url = new StringBuilder(base).append(encodedPath);
 
     if (encodedQueryString != null) {
diff --git a/server/src/test/java/org/apache/druid/server/AsyncManagementForwardingServletTest.java b/server/src/test/java/org/apache/druid/server/AsyncManagementForwardingServletTest.java
index ba7c78b99b0a..b49520021441 100644
--- a/server/src/test/java/org/apache/druid/server/AsyncManagementForwardingServletTest.java
+++ b/server/src/test/java/org/apache/druid/server/AsyncManagementForwardingServletTest.java
@@ -351,12 +351,36 @@ public void testBadProxyDestination() throws Exception
     Assert.assertFalse("overlord called", OVERLORD_EXPECTED_REQUEST.called);
   }
 
+  @Test
+  public void testCoordinatorNoPath() throws Exception
+  {
+    HttpURLConnection connection = ((HttpURLConnection)
+        new URL(StringUtils.format("http://localhost:%d/proxy/coordinator", port)).openConnection());
+    connection.setRequestMethod("GET");
+
+    Assert.assertEquals(403, connection.getResponseCode()); // proxy with no path is not allowed
+    Assert.assertFalse("coordinator called", COORDINATOR_EXPECTED_REQUEST.called);
+    Assert.assertFalse("overlord called", OVERLORD_EXPECTED_REQUEST.called);
+  }
+
+  @Test
+  public void testOverlordNoPath() throws Exception
+  {
+    HttpURLConnection connection = ((HttpURLConnection)
+        new URL(StringUtils.format("http://localhost:%d/proxy/overlord", port)).openConnection());
+    connection.setRequestMethod("GET");
+
+    Assert.assertEquals(403, connection.getResponseCode()); // proxy with no path is not allowed
+    Assert.assertFalse("coordinator called", COORDINATOR_EXPECTED_REQUEST.called);
+    Assert.assertFalse("overlord called", OVERLORD_EXPECTED_REQUEST.called);
+  }
+
   @Test
   public void testCoordinatorLeaderUnknown() throws Exception
   {
     isValidLeader = false;
     HttpURLConnection connection = ((HttpURLConnection)
-        new URL(StringUtils.format("http://localhost:%d/druid/coordinator", port)).openConnection());
+        new URL(StringUtils.format("http://localhost:%d/druid/coordinator/status", port)).openConnection());
     connection.setRequestMethod("GET");
 
     Assert.assertEquals(503, connection.getResponseCode());
@@ -369,7 +393,7 @@ public void testOverlordLeaderUnknown() throws Exception
   {
     isValidLeader = false;
     HttpURLConnection connection = ((HttpURLConnection)
-        new URL(StringUtils.format("http://localhost:%d/druid/indexer", port)).openConnection());
+        new URL(StringUtils.format("http://localhost:%d/druid/indexer/status", port)).openConnection());
     connection.setRequestMethod("GET");
 
     Assert.assertEquals(503, connection.getResponseCode());
diff --git a/server/src/test/java/org/apache/druid/server/JettyUtilsTest.java b/server/src/test/java/org/apache/druid/server/JettyUtilsTest.java
index bd6d86f36bc7..de1cb2bf0b3f 100644
--- a/server/src/test/java/org/apache/druid/server/JettyUtilsTest.java
+++ b/server/src/test/java/org/apache/druid/server/JettyUtilsTest.java
@@ -36,4 +36,28 @@ public void testConcatenateForRewrite()
         )
     );
   }
+
+  @Test
+  public void testConcatenateForRewriteEmptyPath()
+  {
+    Assert.assertNull(
+        JettyUtils.concatenateForRewrite(
+            "http://example.com",
+            "",
+            "q=baz%20qux"
+        )
+    );
+  }
+
+  @Test
+  public void testConcatenateForRewriteInvalidPath()
+  {
+    Assert.assertNull(
+        JettyUtils.concatenateForRewrite(
+            "http://example.com",
+            "foo%20bar", // path must start with '/'
+            "q=baz%20qux"
+        )
+    );
+  }
 }

From 06137a3878ca294b9e438ad5cc40d310bbdde4dd Mon Sep 17 00:00:00 2001
From: Akshat Jain <akjn11@gmail.com>
Date: Wed, 19 Mar 2025 22:11:20 +0530
Subject: [PATCH 44/99] CI improvement: Leverage cancelled() instead of
 always() for CI jobs (#17819)

---
 .github/workflows/unit-and-integration-tests-unified.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/unit-and-integration-tests-unified.yml b/.github/workflows/unit-and-integration-tests-unified.yml
index 15eb29df604e..e15bdaa278ec 100644
--- a/.github/workflows/unit-and-integration-tests-unified.yml
+++ b/.github/workflows/unit-and-integration-tests-unified.yml
@@ -209,12 +209,12 @@ jobs:
 
   standard-its:
     needs: [build, unit-tests-unapproved, check-approval]
-    if: ${{ always() && (needs.check-approval.outputs.approved == 'true' || needs.unit-tests-unapproved.result == 'success') }}
+    if: ${{ !cancelled() && (needs.check-approval.outputs.approved == 'true' || needs.unit-tests-unapproved.result == 'success') }}
     uses: ./.github/workflows/standard-its.yml
 
   revised-its:
     needs: [build, unit-tests-unapproved, check-approval]
-    if: ${{ always() && (needs.check-approval.outputs.approved == 'true' || needs.unit-tests-unapproved.result == 'success') }}
+    if: ${{ !cancelled() && (needs.check-approval.outputs.approved == 'true' || needs.unit-tests-unapproved.result == 'success') }}
     uses: ./.github/workflows/revised-its.yml
     with:
       BACKWARD_COMPATIBILITY_IT_ENABLED: ${{ needs.set-env-var.outputs.BACKWARD_COMPATIBILITY_IT_ENABLED }}
@@ -225,6 +225,6 @@ jobs:
   actions-timeline:
     needs: [build, unit-tests-approved, unit-tests-unapproved, revised-its, standard-its]
     runs-on: ubuntu-latest
-    if: ${{ always() }}
+    if: ${{ !cancelled() }}
     steps:
       - uses: Kesin11/actions-timeline@427ee2cf860166e404d0d69b4f2b24012bb7af4f

From ca03674185447181aace3a019c81b3c955ac1533 Mon Sep 17 00:00:00 2001
From: Zoltan Haindrich <kirk@rxd.hu>
Date: Thu, 20 Mar 2025 08:58:31 +0100
Subject: [PATCH 45/99] Make MSQ tests use the same datasets as other similar
 tests (#17818)

MSQ tests had their own way of creating the segments/etc - this have lead to that custom datasets didn't worked with them.
This patch alters a few things to make it possible to access CompleteSegment for the active segments - which fixed the issue and also enabled the removal of the extra loading codes.
---
 .../druid/msq/test/CalciteMSQTestsHelper.java | 329 +-----------------
 .../dart_with_datasets.iq                     |  13 +
 .../SpecificSegmentsQuerySegmentWalker.java   |  41 ++-
 .../sql/calcite/util/SqlTestFramework.java    |   1 -
 4 files changed, 58 insertions(+), 326 deletions(-)
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/dart_with_datasets.iq

diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/CalciteMSQTestsHelper.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/CalciteMSQTestsHelper.java
index 6a94124e7682..58f5a7b30624 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/CalciteMSQTestsHelper.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/CalciteMSQTestsHelper.java
@@ -20,9 +20,6 @@
 package org.apache.druid.msq.test;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.google.common.cache.CacheBuilder;
-import com.google.common.cache.CacheLoader;
-import com.google.common.cache.LoadingCache;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.inject.Binder;
@@ -32,10 +29,6 @@
 import com.google.inject.TypeLiteral;
 import org.apache.druid.collections.ReferenceCountingResourceHolder;
 import org.apache.druid.collections.ResourceHolder;
-import org.apache.druid.data.input.ResourceInputSource;
-import org.apache.druid.data.input.impl.DimensionsSpec;
-import org.apache.druid.data.input.impl.LongDimensionSchema;
-import org.apache.druid.data.input.impl.StringDimensionSchema;
 import org.apache.druid.discovery.NodeRole;
 import org.apache.druid.frame.processor.Bouncer;
 import org.apache.druid.guice.IndexingServiceTuningConfigModule;
@@ -44,8 +37,6 @@
 import org.apache.druid.guice.annotations.Self;
 import org.apache.druid.indexing.common.SegmentCacheManagerFactory;
 import org.apache.druid.initialization.DruidModule;
-import org.apache.druid.java.util.common.ISE;
-import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.java.util.common.concurrent.Execs;
 import org.apache.druid.java.util.common.io.Closer;
 import org.apache.druid.msq.counters.ChannelCounters;
@@ -56,67 +47,33 @@
 import org.apache.druid.msq.querykit.DataSegmentProvider;
 import org.apache.druid.query.DruidProcessingConfig;
 import org.apache.druid.query.ForwardingQueryProcessingPool;
-import org.apache.druid.query.NestedDataTestUtils;
 import org.apache.druid.query.QueryProcessingPool;
-import org.apache.druid.query.aggregation.CountAggregatorFactory;
-import org.apache.druid.query.aggregation.DoubleSumAggregatorFactory;
-import org.apache.druid.query.aggregation.FloatSumAggregatorFactory;
-import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
-import org.apache.druid.query.aggregation.hyperloglog.HyperUniquesAggregatorFactory;
 import org.apache.druid.query.groupby.GroupByQueryConfig;
 import org.apache.druid.query.groupby.GroupByQueryRunnerTest;
 import org.apache.druid.query.groupby.GroupingEngine;
 import org.apache.druid.query.groupby.TestGroupByBuffers;
 import org.apache.druid.segment.CompleteSegment;
-import org.apache.druid.segment.CursorFactory;
-import org.apache.druid.segment.IndexBuilder;
-import org.apache.druid.segment.IndexSpec;
-import org.apache.druid.segment.QueryableIndex;
-import org.apache.druid.segment.QueryableIndexCursorFactory;
-import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.TestIndex;
-import org.apache.druid.segment.incremental.IncrementalIndex;
-import org.apache.druid.segment.incremental.IncrementalIndexSchema;
 import org.apache.druid.segment.loading.DataSegmentPusher;
 import org.apache.druid.segment.loading.LocalDataSegmentPusher;
 import org.apache.druid.segment.loading.LocalDataSegmentPusherConfig;
 import org.apache.druid.segment.loading.SegmentCacheManager;
 import org.apache.druid.segment.realtime.appenderator.AppenderatorsManager;
-import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
 import org.apache.druid.server.SegmentManager;
+import org.apache.druid.server.SpecificSegmentsQuerySegmentWalker;
 import org.apache.druid.server.coordination.DataSegmentAnnouncer;
 import org.apache.druid.server.coordination.NoopDataSegmentAnnouncer;
-import org.apache.druid.sql.calcite.CalciteNestedDataQueryTest;
 import org.apache.druid.sql.calcite.TempDirProducer;
-import org.apache.druid.sql.calcite.util.CalciteTests;
-import org.apache.druid.sql.calcite.util.TestDataBuilder;
-import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.SegmentId;
-import org.apache.druid.timeline.partition.LinearShardSpec;
 import org.easymock.EasyMock;
-import org.joda.time.Interval;
 import org.mockito.Mockito;
 
-import javax.annotation.Nullable;
 import java.io.File;
 import java.util.List;
 import java.util.Set;
-import java.util.UUID;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
-import static org.apache.druid.sql.calcite.util.CalciteTests.ARRAYS_DATASOURCE;
-import static org.apache.druid.sql.calcite.util.CalciteTests.DATASOURCE1;
-import static org.apache.druid.sql.calcite.util.CalciteTests.DATASOURCE2;
-import static org.apache.druid.sql.calcite.util.CalciteTests.DATASOURCE3;
-import static org.apache.druid.sql.calcite.util.CalciteTests.DATASOURCE5;
-import static org.apache.druid.sql.calcite.util.CalciteTests.WIKIPEDIA;
-import static org.apache.druid.sql.calcite.util.TestDataBuilder.INDEX_SCHEMA_LOTS_O_COLUMNS;
-import static org.apache.druid.sql.calcite.util.TestDataBuilder.INDEX_SCHEMA_NUMERIC_DIMS;
-import static org.apache.druid.sql.calcite.util.TestDataBuilder.ROWS1;
-import static org.apache.druid.sql.calcite.util.TestDataBuilder.ROWS1_WITH_NUMERIC_DIMS;
-import static org.apache.druid.sql.calcite.util.TestDataBuilder.ROWS2;
-import static org.apache.druid.sql.calcite.util.TestDataBuilder.ROWS_LOTS_OF_COLUMNS;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.doReturn;
@@ -198,29 +155,23 @@ public DataSegmentProvider provideDataSegmentProvider(LocalDataSegmentProvider l
     }
 
     @LazySingleton
-    static class LocalDataSegmentProvider extends CacheLoader<SegmentId, CompleteSegment> implements DataSegmentProvider
+    static class LocalDataSegmentProvider implements DataSegmentProvider
     {
-      private TempDirProducer tempDirProducer;
-      private LoadingCache<SegmentId, CompleteSegment> cache;
+      private SpecificSegmentsQuerySegmentWalker walker;
 
       @Inject
-      public LocalDataSegmentProvider(TempDirProducer tempDirProducer)
+      public LocalDataSegmentProvider(SpecificSegmentsQuerySegmentWalker walker)
       {
-        this.tempDirProducer = tempDirProducer;
-        this.cache = CacheBuilder.newBuilder().build(this);
+        this.walker = walker;
       }
 
       @Override
-      public CompleteSegment load(SegmentId segmentId) throws Exception
+      public Supplier<ResourceHolder<CompleteSegment>> fetchSegment(
+          SegmentId segmentId,
+          ChannelCounters channelCounters,
+          boolean isReindex)
       {
-        return getSupplierForSegment(tempDirProducer::newTempFolder, segmentId);
-      }
-
-      @Override
-      public Supplier<ResourceHolder<CompleteSegment>> fetchSegment(SegmentId segmentId,
-          ChannelCounters channelCounters, boolean isReindex)
-      {
-        CompleteSegment a = cache.getUnchecked(segmentId);
+        CompleteSegment a = walker.getSegment(segmentId);
         return () -> new ReferenceCountingResourceHolder<>(a, Closer.create());
       }
 
@@ -272,264 +223,4 @@ private static DataServerQueryHandlerFactory getTestDataServerQueryHandlerFactor
     doReturn(dataServerQueryHandler).when(mockFactory).createDataServerQueryHandler(anyString(), any(), any());
     return mockFactory;
   }
-
-  protected static CompleteSegment getSupplierForSegment(
-      Function<String, File> tempFolderProducer,
-      SegmentId segmentId
-  )
-  {
-    final QueryableIndex index;
-    switch (segmentId.getDataSource()) {
-      case WIKIPEDIA:
-        try {
-          final File directory = new File(tempFolderProducer.apply("tmpDir"), StringUtils.format("wikipedia-index-%s", UUID.randomUUID()));
-          final IncrementalIndex incrementalIndex = TestIndex.makeWikipediaIncrementalIndex();
-          TestIndex.INDEX_MERGER.persist(incrementalIndex, directory, IndexSpec.DEFAULT, null);
-          index = TestIndex.INDEX_IO.loadIndex(directory);
-        }
-        catch (Exception e) {
-          throw new RuntimeException(e);
-        }
-        break;
-      case DATASOURCE1:
-        IncrementalIndexSchema foo1Schema = new IncrementalIndexSchema.Builder()
-            .withMetrics(
-                new CountAggregatorFactory("cnt"),
-                new FloatSumAggregatorFactory("m1", "m1"),
-                new DoubleSumAggregatorFactory("m2", "m2"),
-                new HyperUniquesAggregatorFactory("unique_dim1", "dim1")
-            )
-            .withRollup(false)
-            .build();
-        index = IndexBuilder
-            .create()
-            .tmpDir(tempFolderProducer.apply("tmpDir"))
-            .segmentWriteOutMediumFactory(OffHeapMemorySegmentWriteOutMediumFactory.instance())
-            .schema(foo1Schema)
-            .rows(ROWS1)
-            .buildMMappedIndex();
-        break;
-      case DATASOURCE2:
-        final IncrementalIndexSchema indexSchemaDifferentDim3M1Types = new IncrementalIndexSchema.Builder()
-            .withDimensionsSpec(
-                new DimensionsSpec(
-                    ImmutableList.of(
-                        new StringDimensionSchema("dim1"),
-                        new StringDimensionSchema("dim2"),
-                        new LongDimensionSchema("dim3")
-                    )
-                )
-            )
-            .withMetrics(
-                new CountAggregatorFactory("cnt"),
-                new LongSumAggregatorFactory("m1", "m1"),
-                new DoubleSumAggregatorFactory("m2", "m2"),
-                new HyperUniquesAggregatorFactory("unique_dim1", "dim1")
-            )
-            .withRollup(false)
-            .build();
-        index = IndexBuilder
-            .create()
-            .tmpDir(tempFolderProducer.apply("tmpDir"))
-            .segmentWriteOutMediumFactory(OffHeapMemorySegmentWriteOutMediumFactory.instance())
-            .schema(indexSchemaDifferentDim3M1Types)
-            .rows(ROWS2)
-            .buildMMappedIndex();
-        break;
-      case DATASOURCE3:
-      case CalciteTests.BROADCAST_DATASOURCE:
-        index = IndexBuilder
-            .create()
-            .tmpDir(tempFolderProducer.apply("tmpDir"))
-            .segmentWriteOutMediumFactory(OffHeapMemorySegmentWriteOutMediumFactory.instance())
-            .schema(INDEX_SCHEMA_NUMERIC_DIMS)
-            .rows(ROWS1_WITH_NUMERIC_DIMS)
-            .buildMMappedIndex();
-        break;
-      case DATASOURCE5:
-        index = IndexBuilder
-            .create()
-            .tmpDir(tempFolderProducer.apply("tmpDir"))
-            .segmentWriteOutMediumFactory(OffHeapMemorySegmentWriteOutMediumFactory.instance())
-            .schema(INDEX_SCHEMA_LOTS_O_COLUMNS)
-            .rows(ROWS_LOTS_OF_COLUMNS)
-            .buildMMappedIndex();
-        break;
-      case ARRAYS_DATASOURCE:
-        index = IndexBuilder.create()
-                            .tmpDir(tempFolderProducer.apply("tmpDir"))
-                            .segmentWriteOutMediumFactory(OffHeapMemorySegmentWriteOutMediumFactory.instance())
-                            .schema(
-                                new IncrementalIndexSchema.Builder()
-                                    .withTimestampSpec(NestedDataTestUtils.AUTO_SCHEMA.getTimestampSpec())
-                                    .withDimensionsSpec(NestedDataTestUtils.AUTO_SCHEMA.getDimensionsSpec())
-                                    .withMetrics(
-                                        new CountAggregatorFactory("cnt")
-                                    )
-                                    .withRollup(false)
-                                    .build()
-                            )
-                            .inputSource(
-                                ResourceInputSource.of(
-                                    NestedDataTestUtils.class.getClassLoader(),
-                                    NestedDataTestUtils.ARRAY_TYPES_DATA_FILE
-                                )
-                            )
-                            .inputFormat(TestDataBuilder.DEFAULT_JSON_INPUT_FORMAT)
-                            .inputTmpDir(tempFolderProducer.apply("tmpDir"))
-                            .buildMMappedIndex();
-        break;
-      case CalciteNestedDataQueryTest.DATA_SOURCE:
-      case CalciteNestedDataQueryTest.DATA_SOURCE_MIXED:
-        if (segmentId.getPartitionNum() == 0) {
-          index = IndexBuilder.create()
-                              .tmpDir(tempFolderProducer.apply("tmpDir"))
-                              .segmentWriteOutMediumFactory(OffHeapMemorySegmentWriteOutMediumFactory.instance())
-                              .schema(
-                                  new IncrementalIndexSchema.Builder()
-                                      .withMetrics(
-                                          new CountAggregatorFactory("cnt")
-                                      )
-                                      .withDimensionsSpec(CalciteNestedDataQueryTest.ALL_JSON_COLUMNS.getDimensionsSpec())
-                                      .withRollup(false)
-                                      .build()
-                              )
-                              .rows(CalciteNestedDataQueryTest.ROWS)
-                              .buildMMappedIndex();
-        } else if (segmentId.getPartitionNum() == 1) {
-          index = IndexBuilder.create()
-                              .tmpDir(tempFolderProducer.apply("tmpDir"))
-                              .segmentWriteOutMediumFactory(OffHeapMemorySegmentWriteOutMediumFactory.instance())
-                              .schema(
-                                  new IncrementalIndexSchema.Builder()
-                                      .withMetrics(
-                                          new CountAggregatorFactory("cnt")
-                                      )
-                                      .withDimensionsSpec(CalciteNestedDataQueryTest.JSON_AND_SCALAR_MIX.getDimensionsSpec())
-                                      .withRollup(false)
-                                      .build()
-                              )
-                              .rows(CalciteNestedDataQueryTest.ROWS_MIX)
-                              .buildMMappedIndex();
-        } else {
-          throw new ISE("Cannot query segment %s in test runner", segmentId);
-        }
-        break;
-      case CalciteNestedDataQueryTest.DATA_SOURCE_MIXED_2:
-        if (segmentId.getPartitionNum() == 0) {
-          index = IndexBuilder.create()
-                              .tmpDir(tempFolderProducer.apply("tmpDir"))
-                              .segmentWriteOutMediumFactory(OffHeapMemorySegmentWriteOutMediumFactory.instance())
-                              .schema(
-                                  new IncrementalIndexSchema.Builder()
-                                      .withMetrics(
-                                          new CountAggregatorFactory("cnt")
-                                      )
-                                      .withDimensionsSpec(CalciteNestedDataQueryTest.JSON_AND_SCALAR_MIX.getDimensionsSpec())
-                                      .withRollup(false)
-                                      .build()
-                              )
-                              .rows(CalciteNestedDataQueryTest.ROWS_MIX)
-                              .buildMMappedIndex();
-        } else if (segmentId.getPartitionNum() == 1) {
-          index = IndexBuilder.create()
-                      .tmpDir(tempFolderProducer.apply("tmpDir"))
-                      .segmentWriteOutMediumFactory(OffHeapMemorySegmentWriteOutMediumFactory.instance())
-                      .schema(
-                          new IncrementalIndexSchema.Builder()
-                              .withMetrics(
-                                  new CountAggregatorFactory("cnt")
-                              )
-                              .withDimensionsSpec(CalciteNestedDataQueryTest.ALL_JSON_COLUMNS.getDimensionsSpec())
-                              .withRollup(false)
-                              .build()
-                      )
-                      .rows(CalciteNestedDataQueryTest.ROWS)
-                      .buildMMappedIndex();
-        } else {
-          throw new ISE("Cannot query segment %s in test runner", segmentId);
-        }
-        break;
-      case CalciteNestedDataQueryTest.DATA_SOURCE_ALL:
-        index = IndexBuilder.create()
-                            .tmpDir(tempFolderProducer.apply("tmpDir"))
-                            .segmentWriteOutMediumFactory(OffHeapMemorySegmentWriteOutMediumFactory.instance())
-                            .schema(
-                                new IncrementalIndexSchema.Builder()
-                                    .withTimestampSpec(NestedDataTestUtils.AUTO_SCHEMA.getTimestampSpec())
-                                    .withDimensionsSpec(NestedDataTestUtils.AUTO_SCHEMA.getDimensionsSpec())
-                                    .withMetrics(
-                                        new CountAggregatorFactory("cnt")
-                                    )
-                                    .withRollup(false)
-                                    .build()
-                            )
-                            .inputSource(
-                                ResourceInputSource.of(
-                                    NestedDataTestUtils.class.getClassLoader(),
-                                    NestedDataTestUtils.ALL_TYPES_TEST_DATA_FILE
-                                )
-                            )
-                            .inputFormat(TestDataBuilder.DEFAULT_JSON_INPUT_FORMAT)
-                            .inputTmpDir(tempFolderProducer.apply("tmpDir"))
-                            .buildMMappedIndex();
-        break;
-      case CalciteTests.WIKIPEDIA_FIRST_LAST:
-        index = TestDataBuilder.makeWikipediaIndexWithAggregation(tempFolderProducer.apply("tmpDir"));
-        break;
-      case CalciteTests.TBL_WITH_NULLS_PARQUET:
-      case CalciteTests.SML_TBL_PARQUET:
-      case CalciteTests.ALL_TYPES_UNIQ_PARQUET:
-      case CalciteTests.FEW_ROWS_ALL_DATA_PARQUET:
-      case CalciteTests.T_ALL_TYPE_PARQUET:
-        index = TestDataBuilder.getQueryableIndexForDrillDatasource(segmentId.getDataSource(), tempFolderProducer.apply("tmpDir"));
-        break;
-      case CalciteTests.BENCHMARK_DATASOURCE:
-        index = TestDataBuilder.getQueryableIndexForBenchmarkDatasource();
-        break;
-      default:
-        throw new ISE("Cannot query segment %s in test runner", segmentId);
-
-    }
-    Segment segment = new Segment()
-    {
-      @Override
-      public SegmentId getId()
-      {
-        return segmentId;
-      }
-
-      @Override
-      public Interval getDataInterval()
-      {
-        return segmentId.getInterval();
-      }
-
-      @Nullable
-      @Override
-      public QueryableIndex asQueryableIndex()
-      {
-        return index;
-      }
-
-      @Override
-      public CursorFactory asCursorFactory()
-      {
-        return new QueryableIndexCursorFactory(index);
-      }
-
-      @Override
-      public void close()
-      {
-      }
-    };
-    DataSegment dataSegment = DataSegment.builder()
-                                         .dataSource(segmentId.getDataSource())
-                                         .interval(segmentId.getInterval())
-                                         .version(segmentId.getVersion())
-                                         .shardSpec(new LinearShardSpec(0))
-                                         .size(0)
-                                         .build();
-    return new CompleteSegment(dataSegment, segment);
-  }
 }
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/dart_with_datasets.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/dart_with_datasets.iq
new file mode 100644
index 000000000000..65dbce0f087b
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/dart_with_datasets.iq
@@ -0,0 +1,13 @@
+!set dartQueryId 00000000-0000-0000-0000-000000000000
+!use druidtest://?componentSupplier=StandardMSQComponentSupplier&datasets=sql/src/test/quidem/sampledataset
+!set outputformat mysql
+
+select count(1) from "rollup-tutorial";
++--------+
+| EXPR$0 |
++--------+
+|      9 |
++--------+
+(1 row)
+
+!ok
diff --git a/server/src/test/java/org/apache/druid/server/SpecificSegmentsQuerySegmentWalker.java b/server/src/test/java/org/apache/druid/server/SpecificSegmentsQuerySegmentWalker.java
index ff385e99f641..7cc21ecd083c 100644
--- a/server/src/test/java/org/apache/druid/server/SpecificSegmentsQuerySegmentWalker.java
+++ b/server/src/test/java/org/apache/druid/server/SpecificSegmentsQuerySegmentWalker.java
@@ -23,6 +23,8 @@
 import com.google.common.collect.Ordering;
 import com.google.common.io.Closeables;
 import com.google.inject.Injector;
+import org.apache.curator.shaded.com.google.common.collect.Lists;
+import org.apache.druid.error.DruidException;
 import org.apache.druid.query.DataSource;
 import org.apache.druid.query.FrameBasedInlineDataSource;
 import org.apache.druid.query.InlineDataSource;
@@ -34,6 +36,7 @@
 import org.apache.druid.query.SegmentDescriptor;
 import org.apache.druid.query.lookup.LookupExtractorFactoryContainer;
 import org.apache.druid.query.lookup.LookupExtractorFactoryContainerProvider;
+import org.apache.druid.segment.CompleteSegment;
 import org.apache.druid.segment.FrameBasedInlineSegmentWrangler;
 import org.apache.druid.segment.IncrementalIndexSegment;
 import org.apache.druid.segment.InlineSegmentWrangler;
@@ -51,6 +54,7 @@
 import org.apache.druid.server.metrics.NoopServiceEmitter;
 import org.apache.druid.sql.calcite.util.datasets.TestDataSet;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 import org.apache.druid.timeline.partition.LinearShardSpec;
 import org.joda.time.Interval;
@@ -76,8 +80,7 @@ public class SpecificSegmentsQuerySegmentWalker implements QuerySegmentWalker, C
 {
   private final QuerySegmentWalker walker;
   private final Map<String, VersionedIntervalTimeline<String, ReferenceCountingSegment>> timelines;
-  private final List<Closeable> closeables = new ArrayList<>();
-  private final List<DataSegment> segments = new ArrayList<>();
+  private final List<CompleteSegment> segments = new ArrayList<>();
   private static final LookupExtractorFactoryContainerProvider LOOKUP_EXTRACTOR_FACTORY_CONTAINER_PROVIDER =
       new LookupExtractorFactoryContainerProvider()
       {
@@ -185,6 +188,14 @@ public SpecificSegmentsQuerySegmentWalker(
 
   public SpecificSegmentsQuerySegmentWalker add(final DataSegment descriptor, final Segment segment)
   {
+    return add(new CompleteSegment(descriptor, segment));
+  }
+
+  public SpecificSegmentsQuerySegmentWalker add(CompleteSegment completeSegment)
+  {
+    DataSegment descriptor = completeSegment.getDataSegment();
+    Segment segment = completeSegment.getSegment();
+
     final ReferenceCountingSegment referenceCountingSegment =
         ReferenceCountingSegment.wrapSegment(
             segment,
@@ -199,8 +210,7 @@ public SpecificSegmentsQuerySegmentWalker add(final DataSegment descriptor, fina
         descriptor.getVersion(),
         descriptor.getShardSpec().createChunk(referenceCountingSegment)
     );
-    segments.add(descriptor);
-    closeables.add(referenceCountingSegment);
+    segments.add(completeSegment);
     return this;
   }
 
@@ -216,7 +226,7 @@ public SpecificSegmentsQuerySegmentWalker add(final DataSegment descriptor, fina
 
   public List<DataSegment> getSegments()
   {
-    return segments;
+    return Lists.transform(segments, CompleteSegment::getDataSegment);
   }
 
   @Override
@@ -234,7 +244,7 @@ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final
   @Override
   public void close() throws IOException
   {
-    for (Closeable closeable : closeables) {
+    for (Closeable closeable : segments) {
       Closeables.close(closeable, true);
     }
   }
@@ -253,4 +263,23 @@ public SpecificSegmentsQuerySegmentWalker add(TestDataSet dataset, File tmpDir)
         indexNumericDims
     );
   }
+
+  public CompleteSegment getSegment(SegmentId segmentId)
+  {
+    List<CompleteSegment> matches = new ArrayList<>(1);
+    for (CompleteSegment s : segments) {
+      SegmentId id = s.getDataSegment().getId();
+      if (id.equals(segmentId)) {
+        matches.add(s);
+      }
+    }
+    if (matches.size() != 1) {
+      throw DruidException.defensive(
+          "SegmentId [%s] has unexpected number of matches! [%s]",
+          segmentId,
+          matches
+      );
+    }
+    return matches.get(0);
+  }
 }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
index d88af75df644..e99550d08c15 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
@@ -963,7 +963,6 @@ private SystemSchema makeSystemSchema(AuthorizerMapper authorizerMapper, DruidSc
       return CalciteTests.createMockSystemSchema(druidSchema, timelineServerView, authorizerMapper);
     }
 
-
     @Provides
     @LazySingleton
     private TimelineServerView makeTimelineServerView(SpecificSegmentsQuerySegmentWalker walker)

From 553c15e7453dbf02060073a93cf8b48707437a5f Mon Sep 17 00:00:00 2001
From: Andy Tsai <61856143+weishiuntsai@users.noreply.github.com>
Date: Thu, 20 Mar 2025 21:15:39 -0700
Subject: [PATCH 46/99] Add unnest tests to quidem (#17825)

This PR adds the sql-native unnest tests to quidem. This set of tests has 6392 queries in total, with 5247 positive tests and 1145 negative tests.
---
 .../qaUnnest_array_sql.iq                     | 29891 ++++++++++
 .../qaUnnest_array_sql_filter.iq              | 24180 ++++++++
 .../qaUnnest_array_sql_ops.iq                 |   309 +
 .../qaUnnest_array_sql_other_funcs.iq         | 20689 +++++++
 .../qaUnnest_array_sql_scalar_funcs.iq        |  7011 +++
 .../qaUnnest_mv_sql.iq                        | 21585 +++++++
 .../qaUnnest_mv_sql_filter.iq                 | 46780 ++++++++++++++++
 .../qaUnnest_mv_sql_ops.iq                    |   331 +
 .../qaUnnest_mv_sql_other_funcs.iq            |  7720 +++
 .../qaUnnest_mv_sql_scalar_funcs.iq           |  7220 +++
 .../quidem/qatests/qaUnnest/array/ingest.json |    92 +
 .../quidem/qatests/qaUnnest/mv/ingest.json    |   112 +
 12 files changed, 165920 insertions(+)
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql_filter.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql_ops.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql_other_funcs.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql_scalar_funcs.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql_filter.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql_ops.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql_other_funcs.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql_scalar_funcs.iq
 create mode 100644 sql/src/test/quidem/qatests/qaUnnest/array/ingest.json
 create mode 100644 sql/src/test/quidem/qatests/qaUnnest/mv/ingest.json

diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql.iq
new file mode 100644
index 000000000000..45966103fc51
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql.iq
@@ -0,0 +1,29891 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaUnnest/array&numMergeBuffers=3
+!set outputformat mysql
+SELECT *
+FROM test_unnest;
++-------------------------+-------+--------+--------------+--------------+------------------+----------------+--------------------+---------+--------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| __time                  | s_int | s_null | a_bool       | a_int        | a_float          | a_str          | a_null             | a_empty | a_mixed                  | a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------+-------+--------+--------------+--------------+------------------+----------------+--------------------+---------+--------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| 2022-01-01 00:00:00.000 |     1 |        | [1, 0, null] | [1, 2, null] | [0.1, 0.2, null] | [S1, S2, null] | [null, null, null] | []      | [true, 1, 0.1, S1, null] | [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| 2022-02-01 00:00:00.000 |     2 |        | [null, 1, 0] | [null, 1, 2] | [null, 0.1, 0.2] | [null, S1, S2] | [null, null, null] | []      | [null, true, 1, 0.1, S1] | [[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"],[[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"],[[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"]]]] |
+| 2022-03-01 00:00:00.000 |       |        | [0, null, 1] | [2, null, 1] | [0.2, null, 0.1] | [S2, null, S1] | [null, null, null] | []      | [S1, null, true, 1, 0.1] | [[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1],[[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1],[[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1]]]] |
++-------------------------+-------+--------+--------------+--------------+------------------+----------------+--------------------+---------+--------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(doesnt_exist) AS u(c);
+not found
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(doesnt_exist) AS u(c)
+GROUP BY c;
+not found
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT *
+FROM test_unnest,
+     unnest(a_int) AS u(a_int);
+is ambiguous
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT *
+FROM test_unnest,
+     unnest(a_int) AS u(a_int)
+GROUP BY c;
+is ambiguous
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int0
+FROM test_unnest,
+     unnest(a_int) AS u(s_int);
+not found in any table
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT u.s_int
+FROM test_unnest,
+     unnest(a_int) AS u(s_int);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT u.s_int
+   FROM test_unnest,
+        unnest(a_int) AS u(s_int));
++--------+
+| EXPR$0 |
++--------+
+|      9 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM test_unnest,
+     unnest(a_int) AS u(s_int);
++--------+
+| EXPR$0 |
++--------+
+|      9 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int0
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(s_int));
++--------+
+| s_int0 |
++--------+
+|      1 |
+|      1 |
+|      1 |
+|      2 |
+|      2 |
+|      2 |
+|        |
+|        |
+|        |
++--------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(s_int));
++-----+
+| cnt |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B11 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT u.s_int
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(s_int));
+not found
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B12 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int0,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(s_int)
+GROUP BY s_int0;
+not found in any table
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT u.s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(s_int)
+GROUP BY u.s_int;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B14 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     strlen(unnest(a_int)) AS u(c);
+unexpected token
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     strlen(unnest(a_int)) AS u(c)
+GROUP BY c;
+unexpected token
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(array_slice(a_int, 0, 2)) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(array_slice(a_int, 0, 2)) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(array_append(a_int, 9)) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 9 |
+| 9 |
+| 9 |
+|   |
+|   |
+|   |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(array_append(a_int, 9)) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+| 9 |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c || 'Z') col
+FROM test_unnest,
+     unnest(a_int) AS u(c);
++-----+
+| col |
++-----+
+| 1Z  |
+| 1Z  |
+| 1Z  |
+| 2Z  |
+| 2Z  |
+| 2Z  |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c || 'Z') col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY c;
++-----+
+| col |
++-----+
+| 1Z  |
+| 2Z  |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(c) col
+FROM test_unnest,
+     unnest(a_int) AS u(c);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(c) col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY c;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(c || 'Z') col
+FROM test_unnest,
+     unnest(a_int) AS u(c);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(c || 'Z') col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY c;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(c || c) col
+FROM test_unnest,
+     unnest(a_int) AS u(c);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(c || c) col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY c;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B28 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       a_int AS new_col
+FROM test_unnest,
+     unnest(new_col) AS u(c);
+not found in any table
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_int AS new_col
+   FROM test_unnest) t1,
+     unnest(new_col) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+|   |
+|   |
+|   |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c AS new_col
+FROM test_unnest,
+     unnest(a_int) AS u(c);
++---------+
+| new_col |
++---------+
+|       1 |
+|       1 |
+|       1 |
+|       2 |
+|       2 |
+|       2 |
+|         |
+|         |
+|         |
++---------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A1_B1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(s_int) AS u(c);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A1_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(s_int) AS u(c)
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A2_B1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(s_null) AS u(c);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A2_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(s_null) AS u(c)
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A3_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_null) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A3_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_null) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_empty) AS u(c);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A4_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_empty) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A5_B1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_nested) AS u(c);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A5_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_nested) AS u(c)
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM unnest(array[NULL, 1, 2]) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A6_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM unnest(array[NULL, 1, 2]) AS u(c)
+GROUP BY c;
++---+-----+
+| c | cnt |
++---+-----+
+| 1 |   1 |
+| 2 |   1 |
+|   |   1 |
++---+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(array_append(a_int, 9)) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 9 |
+| 9 |
+| 9 |
+|   |
+|   |
+|   |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A7_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(array_append(a_int, 9)) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+| 9 |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A8_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(array_concat(a_int, a_int)) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A8_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(array_concat(a_int, a_int)) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A9_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(array_slice(a_int, 0, 2)) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A9_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(array_slice(a_int, 0, 2)) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A10_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c);
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+| 1 |
+|   |
+|   |
+|   |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A10_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A11_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+|   |
+|   |
+|   |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A11_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A12_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A12_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY c;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A13_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c);
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+| S2 |
+|    |
+|    |
+|    |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A13_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY c;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A14_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c);
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| S1   |
+| true |
+| true |
+| true |
+|      |
+|      |
+|      |
++------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A14_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY c;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A15_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c);
++-------+
+| c     |
++-------+
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A15_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY c;
++-------+
+| c     |
++-------+
+| false |
+| true  |
+|       |
++-------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A16_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+|   |
+|   |
+|   |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A16_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A17_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A17_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY c;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A18_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c);
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+| S2 |
+|    |
+|    |
+|    |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A18_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY c;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A19_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A19_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A20_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A20_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A21_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c);
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| S1   |
+| true |
+| true |
+| true |
+|      |
+|      |
+|      |
++------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_array TEST_ID: A21_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY c;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+|   |
+|   |
+|   |
++---+
+(9 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "unnest",
+    "base" : {
+      "type" : "table",
+      "name" : "test_unnest"
+    },
+    "virtualColumn" : {
+      "type" : "expression",
+      "name" : "j0.unnest",
+      "expression" : "\"a_int\"",
+      "outputType" : "ARRAY<LONG>"
+    },
+    "unnestFilter" : null
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "resultFormat" : "compactedList",
+  "columns" : [ "j0.unnest" ],
+  "columnTypes" : [ "LONG" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A1_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT *
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c));
++-------------------------+-------+--------+--------------+--------------+------------------+----------------+--------------------+---------+--------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---+
+| __time                  | s_int | s_null | a_bool       | a_int        | a_float          | a_str          | a_null             | a_empty | a_mixed                  | a_nested                                                                                                                                                                                                                                                                                                                      | c |
++-------------------------+-------+--------+--------------+--------------+------------------+----------------+--------------------+---------+--------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---+
+| 2022-01-01 00:00:00.000 |     1 |        | [1, 0, null] | [1, 2, null] | [0.1, 0.2, null] | [S1, S2, null] | [null, null, null] | []      | [true, 1, 0.1, S1, null] | [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] | 1 |
+| 2022-01-01 00:00:00.000 |     1 |        | [1, 0, null] | [1, 2, null] | [0.1, 0.2, null] | [S1, S2, null] | [null, null, null] | []      | [true, 1, 0.1, S1, null] | [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] | 2 |
+| 2022-01-01 00:00:00.000 |     1 |        | [1, 0, null] | [1, 2, null] | [0.1, 0.2, null] | [S1, S2, null] | [null, null, null] | []      | [true, 1, 0.1, S1, null] | [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   |
+| 2022-02-01 00:00:00.000 |     2 |        | [null, 1, 0] | [null, 1, 2] | [null, 0.1, 0.2] | [null, S1, S2] | [null, null, null] | []      | [null, true, 1, 0.1, S1] | [[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"],[[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"],[[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"]]]] | 1 |
+| 2022-02-01 00:00:00.000 |     2 |        | [null, 1, 0] | [null, 1, 2] | [null, 0.1, 0.2] | [null, S1, S2] | [null, null, null] | []      | [null, true, 1, 0.1, S1] | [[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"],[[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"],[[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"]]]] | 2 |
+| 2022-02-01 00:00:00.000 |     2 |        | [null, 1, 0] | [null, 1, 2] | [null, 0.1, 0.2] | [null, S1, S2] | [null, null, null] | []      | [null, true, 1, 0.1, S1] | [[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"],[[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"],[[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"]]]] |   |
+| 2022-03-01 00:00:00.000 |       |        | [0, null, 1] | [2, null, 1] | [0.2, null, 0.1] | [S2, null, S1] | [null, null, null] | []      | [S1, null, true, 1, 0.1] | [[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1],[[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1],[[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1]]]] | 1 |
+| 2022-03-01 00:00:00.000 |       |        | [0, null, 1] | [2, null, 1] | [0.2, null, 0.1] | [S2, null, S1] | [null, null, null] | []      | [S1, null, true, 1, 0.1] | [[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1],[[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1],[[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1]]]] | 2 |
+| 2022-03-01 00:00:00.000 |       |        | [0, null, 1] | [2, null, 1] | [0.2, null, 0.1] | [S2, null, S1] | [null, null, null] | []      | [S1, null, true, 1, 0.1] | [[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1],[[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1],[[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1]]]] |   |
++-------------------------+-------+--------+--------------+--------------+------------------+----------------+--------------------+---------+--------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---+
+(9 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "unnest",
+    "base" : {
+      "type" : "table",
+      "name" : "test_unnest"
+    },
+    "virtualColumn" : {
+      "type" : "expression",
+      "name" : "j0.unnest",
+      "expression" : "\"a_int\"",
+      "outputType" : "ARRAY<LONG>"
+    },
+    "unnestFilter" : null
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "resultFormat" : "compactedList",
+  "columns" : [ "__time", "s_int", "s_null", "a_bool", "a_int", "a_float", "a_str", "a_null", "a_empty", "a_mixed", "a_nested", "j0.unnest" ],
+  "columnTypes" : [ "LONG", "LONG", "STRING", "ARRAY<LONG>", "ARRAY<LONG>", "ARRAY<DOUBLE>", "ARRAY<STRING>", "ARRAY<LONG>", "ARRAY<LONG>", "ARRAY<STRING>", "COMPLEX<json>", "LONG" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A1_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY c;
++---+-----+
+| c | cnt |
++---+-----+
+| 1 |   3 |
+| 2 |   3 |
+|   |   3 |
++---+-----+
+(3 rows)
+
+!ok
+
+{
+  "queryType" : "groupBy",
+  "dataSource" : {
+    "type" : "unnest",
+    "base" : {
+      "type" : "table",
+      "name" : "test_unnest"
+    },
+    "virtualColumn" : {
+      "type" : "expression",
+      "name" : "j0.unnest",
+      "expression" : "\"a_int\"",
+      "outputType" : "ARRAY<LONG>"
+    },
+    "unnestFilter" : null
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "granularity" : {
+    "type" : "all"
+  },
+  "dimensions" : [ {
+    "type" : "default",
+    "dimension" : "j0.unnest",
+    "outputName" : "d0",
+    "outputType" : "LONG"
+  } ],
+  "aggregations" : [ {
+    "type" : "count",
+    "name" : "a0"
+  } ],
+  "limitSpec" : {
+    "type" : "NoopLimitSpec"
+  }
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c);
++-----+
+| cnt |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A1_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c);
++-----+
+| cnt |
++-----+
+|   6 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A1_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A2_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c);
++-----+
+| cnt |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A2_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c);
++-----+
+| cnt |
++-----+
+|   6 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A2_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A3_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c);
++-----+
+| cnt |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A3_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c);
++-----+
+| cnt |
++-----+
+|   6 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A3_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c);
++-----+
+| cnt |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A4_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c);
++-----+
+| cnt |
++-----+
+|   6 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A4_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c);
++-----+
+| cnt |
++-----+
+|  15 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A5_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c);
++-----+
+| cnt |
++-----+
+|  12 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A5_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c);
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c);
++-----+
+| cnt |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A6_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c);
++-----+
+| cnt |
++-----+
+|   6 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A6_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c);
++-----+
+| cnt |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A7_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c);
++-----+
+| cnt |
++-----+
+|   6 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A7_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A8_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c);
++-----+
+| cnt |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A8_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c);
++-----+
+| cnt |
++-----+
+|   6 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A8_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A9_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c);
++-----+
+| cnt |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A9_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c);
++-----+
+| cnt |
++-----+
+|   6 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A9_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A10_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c);
++-----+
+| cnt |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A10_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c);
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A10_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c);
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A11_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c);
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A11_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c);
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A11_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c);
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A12_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c);
++-----+
+| cnt |
++-----+
+|  15 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A12_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c);
++-----+
+| cnt |
++-----+
+|  12 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A12_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c);
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A1_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A2_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(a_int) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A2_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A3_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(a_float) AS u(c);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A3_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY c;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(a_str) AS u(c);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A4_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY c;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A5_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY c;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c);
++-------+
+| c     |
++-------+
+| false |
+| true  |
+|       |
++-------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A6_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY c;
++-------+
+| c     |
++-------+
+| false |
+| true  |
+|       |
++-------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A7_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A8_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A8_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY c;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A9_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A9_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY c;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A10_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A10_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A11_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A11_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A12_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A12_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY c;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A6_B6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u2(c2);
++-------+-------+
+| c1    | c2    |
++-------+-------+
+| false | false |
+| false | false |
+| false | false |
+| false | true  |
+| false | true  |
+| false | true  |
+| false |       |
+| false |       |
+| false |       |
+| true  | false |
+| true  | false |
+| true  | false |
+| true  | true  |
+| true  | true  |
+| true  | true  |
+| true  |       |
+| true  |       |
+| true  |       |
+|       | false |
+|       | false |
+|       | false |
+|       | true  |
+|       | true  |
+|       | true  |
+|       |       |
+|       |       |
+|       |       |
++-------+-------+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A6_B7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u2(c2);
++-------+----+
+| c1    | c2 |
++-------+----+
+| false |  1 |
+| false |  1 |
+| false |  1 |
+| false |  2 |
+| false |  2 |
+| false |  2 |
+| false |    |
+| false |    |
+| false |    |
+| true  |  1 |
+| true  |  1 |
+| true  |  1 |
+| true  |  2 |
+| true  |  2 |
+| true  |  2 |
+| true  |    |
+| true  |    |
+| true  |    |
+|       |  1 |
+|       |  1 |
+|       |  1 |
+|       |  2 |
+|       |  2 |
+|       |  2 |
+|       |    |
+|       |    |
+|       |    |
++-------+----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A6_B8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u2(c2);
++-------+-----+
+| c1    | c2  |
++-------+-----+
+| false | 0.1 |
+| false | 0.1 |
+| false | 0.1 |
+| false | 0.2 |
+| false | 0.2 |
+| false | 0.2 |
+| false |     |
+| false |     |
+| false |     |
+| true  | 0.1 |
+| true  | 0.1 |
+| true  | 0.1 |
+| true  | 0.2 |
+| true  | 0.2 |
+| true  | 0.2 |
+| true  |     |
+| true  |     |
+| true  |     |
+|       | 0.1 |
+|       | 0.1 |
+|       | 0.1 |
+|       | 0.2 |
+|       | 0.2 |
+|       | 0.2 |
+|       |     |
+|       |     |
+|       |     |
++-------+-----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A6_B9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u2(c2);
++-------+----+
+| c1    | c2 |
++-------+----+
+| false | S1 |
+| false | S1 |
+| false | S1 |
+| false | S2 |
+| false | S2 |
+| false | S2 |
+| false |    |
+| false |    |
+| false |    |
+| true  | S1 |
+| true  | S1 |
+| true  | S1 |
+| true  | S2 |
+| true  | S2 |
+| true  | S2 |
+| true  |    |
+| true  |    |
+| true  |    |
+|       | S1 |
+|       | S1 |
+|       | S1 |
+|       | S2 |
+|       | S2 |
+|       | S2 |
+|       |    |
+|       |    |
+|       |    |
++-------+----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A6_B10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u2(c2);
++-------+----+
+| c1    | c2 |
++-------+----+
+| false |    |
+| false |    |
+| false |    |
+| false |    |
+| false |    |
+| false |    |
+| false |    |
+| false |    |
+| false |    |
+| true  |    |
+| true  |    |
+| true  |    |
+| true  |    |
+| true  |    |
+| true  |    |
+| true  |    |
+| true  |    |
+| true  |    |
+|       |    |
+|       |    |
+|       |    |
+|       |    |
+|       |    |
+|       |    |
+|       |    |
+|       |    |
+|       |    |
++-------+----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A6_B11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
++----+----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A6_B12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u2(c2);
++-------+------+
+| c1    | c2   |
++-------+------+
+| false | 0.1  |
+| false | 0.1  |
+| false | 0.1  |
+| false | 1    |
+| false | 1    |
+| false | 1    |
+| false | S1   |
+| false | S1   |
+| false | S1   |
+| false | true |
+| false | true |
+| false | true |
+| false |      |
+| false |      |
+| false |      |
+| true  | 0.1  |
+| true  | 0.1  |
+| true  | 0.1  |
+| true  | 1    |
+| true  | 1    |
+| true  | 1    |
+| true  | S1   |
+| true  | S1   |
+| true  | S1   |
+| true  | true |
+| true  | true |
+| true  | true |
+| true  |      |
+| true  |      |
+| true  |      |
+|       | 0.1  |
+|       | 0.1  |
+|       | 0.1  |
+|       | 1    |
+|       | 1    |
+|       | 1    |
+|       | S1   |
+|       | S1   |
+|       | S1   |
+|       | true |
+|       | true |
+|       | true |
+|       |      |
+|       |      |
+|       |      |
++-------+------+
+(45 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A7_B6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u2(c2);
++----+-------+
+| c1 | c2    |
++----+-------+
+|  1 | false |
+|  1 | false |
+|  1 | false |
+|  1 | true  |
+|  1 | true  |
+|  1 | true  |
+|  1 |       |
+|  1 |       |
+|  1 |       |
+|  2 | false |
+|  2 | false |
+|  2 | false |
+|  2 | true  |
+|  2 | true  |
+|  2 | true  |
+|  2 |       |
+|  2 |       |
+|  2 |       |
+|    | false |
+|    | false |
+|    | false |
+|    | true  |
+|    | true  |
+|    | true  |
+|    |       |
+|    |       |
+|    |       |
++----+-------+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A7_B7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
+|  1 |  1 |
+|  1 |  1 |
+|  1 |  1 |
+|  1 |  2 |
+|  1 |  2 |
+|  1 |  2 |
+|  1 |    |
+|  1 |    |
+|  1 |    |
+|  2 |  1 |
+|  2 |  1 |
+|  2 |  1 |
+|  2 |  2 |
+|  2 |  2 |
+|  2 |  2 |
+|  2 |    |
+|  2 |    |
+|  2 |    |
+|    |  1 |
+|    |  1 |
+|    |  1 |
+|    |  2 |
+|    |  2 |
+|    |  2 |
+|    |    |
+|    |    |
+|    |    |
++----+----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A7_B8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u2(c2);
++----+-----+
+| c1 | c2  |
++----+-----+
+|  1 | 0.1 |
+|  1 | 0.1 |
+|  1 | 0.1 |
+|  1 | 0.2 |
+|  1 | 0.2 |
+|  1 | 0.2 |
+|  1 |     |
+|  1 |     |
+|  1 |     |
+|  2 | 0.1 |
+|  2 | 0.1 |
+|  2 | 0.1 |
+|  2 | 0.2 |
+|  2 | 0.2 |
+|  2 | 0.2 |
+|  2 |     |
+|  2 |     |
+|  2 |     |
+|    | 0.1 |
+|    | 0.1 |
+|    | 0.1 |
+|    | 0.2 |
+|    | 0.2 |
+|    | 0.2 |
+|    |     |
+|    |     |
+|    |     |
++----+-----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A7_B9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
+|  1 | S1 |
+|  1 | S1 |
+|  1 | S1 |
+|  1 | S2 |
+|  1 | S2 |
+|  1 | S2 |
+|  1 |    |
+|  1 |    |
+|  1 |    |
+|  2 | S1 |
+|  2 | S1 |
+|  2 | S1 |
+|  2 | S2 |
+|  2 | S2 |
+|  2 | S2 |
+|  2 |    |
+|  2 |    |
+|  2 |    |
+|    | S1 |
+|    | S1 |
+|    | S1 |
+|    | S2 |
+|    | S2 |
+|    | S2 |
+|    |    |
+|    |    |
+|    |    |
++----+----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A7_B10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
+|  1 |    |
+|  1 |    |
+|  1 |    |
+|  1 |    |
+|  1 |    |
+|  1 |    |
+|  1 |    |
+|  1 |    |
+|  1 |    |
+|  2 |    |
+|  2 |    |
+|  2 |    |
+|  2 |    |
+|  2 |    |
+|  2 |    |
+|  2 |    |
+|  2 |    |
+|  2 |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
++----+----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A7_B11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
++----+----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A7_B12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u2(c2);
++----+------+
+| c1 | c2   |
++----+------+
+|  1 | 0.1  |
+|  1 | 0.1  |
+|  1 | 0.1  |
+|  1 | 1    |
+|  1 | 1    |
+|  1 | 1    |
+|  1 | S1   |
+|  1 | S1   |
+|  1 | S1   |
+|  1 | true |
+|  1 | true |
+|  1 | true |
+|  1 |      |
+|  1 |      |
+|  1 |      |
+|  2 | 0.1  |
+|  2 | 0.1  |
+|  2 | 0.1  |
+|  2 | 1    |
+|  2 | 1    |
+|  2 | 1    |
+|  2 | S1   |
+|  2 | S1   |
+|  2 | S1   |
+|  2 | true |
+|  2 | true |
+|  2 | true |
+|  2 |      |
+|  2 |      |
+|  2 |      |
+|    | 0.1  |
+|    | 0.1  |
+|    | 0.1  |
+|    | 1    |
+|    | 1    |
+|    | 1    |
+|    | S1   |
+|    | S1   |
+|    | S1   |
+|    | true |
+|    | true |
+|    | true |
+|    |      |
+|    |      |
+|    |      |
++----+------+
+(45 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A8_B6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u2(c2);
++-----+-------+
+| c1  | c2    |
++-----+-------+
+| 0.1 | false |
+| 0.1 | false |
+| 0.1 | false |
+| 0.1 | true  |
+| 0.1 | true  |
+| 0.1 | true  |
+| 0.1 |       |
+| 0.1 |       |
+| 0.1 |       |
+| 0.2 | false |
+| 0.2 | false |
+| 0.2 | false |
+| 0.2 | true  |
+| 0.2 | true  |
+| 0.2 | true  |
+| 0.2 |       |
+| 0.2 |       |
+| 0.2 |       |
+|     | false |
+|     | false |
+|     | false |
+|     | true  |
+|     | true  |
+|     | true  |
+|     |       |
+|     |       |
+|     |       |
++-----+-------+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A8_B7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u2(c2);
++-----+----+
+| c1  | c2 |
++-----+----+
+| 0.1 |  1 |
+| 0.1 |  1 |
+| 0.1 |  1 |
+| 0.1 |  2 |
+| 0.1 |  2 |
+| 0.1 |  2 |
+| 0.1 |    |
+| 0.1 |    |
+| 0.1 |    |
+| 0.2 |  1 |
+| 0.2 |  1 |
+| 0.2 |  1 |
+| 0.2 |  2 |
+| 0.2 |  2 |
+| 0.2 |  2 |
+| 0.2 |    |
+| 0.2 |    |
+| 0.2 |    |
+|     |  1 |
+|     |  1 |
+|     |  1 |
+|     |  2 |
+|     |  2 |
+|     |  2 |
+|     |    |
+|     |    |
+|     |    |
++-----+----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A8_B8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u2(c2);
++-----+-----+
+| c1  | c2  |
++-----+-----+
+| 0.1 | 0.1 |
+| 0.1 | 0.1 |
+| 0.1 | 0.1 |
+| 0.1 | 0.2 |
+| 0.1 | 0.2 |
+| 0.1 | 0.2 |
+| 0.1 |     |
+| 0.1 |     |
+| 0.1 |     |
+| 0.2 | 0.1 |
+| 0.2 | 0.1 |
+| 0.2 | 0.1 |
+| 0.2 | 0.2 |
+| 0.2 | 0.2 |
+| 0.2 | 0.2 |
+| 0.2 |     |
+| 0.2 |     |
+| 0.2 |     |
+|     | 0.1 |
+|     | 0.1 |
+|     | 0.1 |
+|     | 0.2 |
+|     | 0.2 |
+|     | 0.2 |
+|     |     |
+|     |     |
+|     |     |
++-----+-----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A8_B9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u2(c2);
++-----+----+
+| c1  | c2 |
++-----+----+
+| 0.1 | S1 |
+| 0.1 | S1 |
+| 0.1 | S1 |
+| 0.1 | S2 |
+| 0.1 | S2 |
+| 0.1 | S2 |
+| 0.1 |    |
+| 0.1 |    |
+| 0.1 |    |
+| 0.2 | S1 |
+| 0.2 | S1 |
+| 0.2 | S1 |
+| 0.2 | S2 |
+| 0.2 | S2 |
+| 0.2 | S2 |
+| 0.2 |    |
+| 0.2 |    |
+| 0.2 |    |
+|     | S1 |
+|     | S1 |
+|     | S1 |
+|     | S2 |
+|     | S2 |
+|     | S2 |
+|     |    |
+|     |    |
+|     |    |
++-----+----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A8_B10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u2(c2);
++-----+----+
+| c1  | c2 |
++-----+----+
+| 0.1 |    |
+| 0.1 |    |
+| 0.1 |    |
+| 0.1 |    |
+| 0.1 |    |
+| 0.1 |    |
+| 0.1 |    |
+| 0.1 |    |
+| 0.1 |    |
+| 0.2 |    |
+| 0.2 |    |
+| 0.2 |    |
+| 0.2 |    |
+| 0.2 |    |
+| 0.2 |    |
+| 0.2 |    |
+| 0.2 |    |
+| 0.2 |    |
+|     |    |
+|     |    |
+|     |    |
+|     |    |
+|     |    |
+|     |    |
+|     |    |
+|     |    |
+|     |    |
++-----+----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A8_B11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
++----+----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A8_B12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u2(c2);
++-----+------+
+| c1  | c2   |
++-----+------+
+| 0.1 | 0.1  |
+| 0.1 | 0.1  |
+| 0.1 | 0.1  |
+| 0.1 | 1    |
+| 0.1 | 1    |
+| 0.1 | 1    |
+| 0.1 | S1   |
+| 0.1 | S1   |
+| 0.1 | S1   |
+| 0.1 | true |
+| 0.1 | true |
+| 0.1 | true |
+| 0.1 |      |
+| 0.1 |      |
+| 0.1 |      |
+| 0.2 | 0.1  |
+| 0.2 | 0.1  |
+| 0.2 | 0.1  |
+| 0.2 | 1    |
+| 0.2 | 1    |
+| 0.2 | 1    |
+| 0.2 | S1   |
+| 0.2 | S1   |
+| 0.2 | S1   |
+| 0.2 | true |
+| 0.2 | true |
+| 0.2 | true |
+| 0.2 |      |
+| 0.2 |      |
+| 0.2 |      |
+|     | 0.1  |
+|     | 0.1  |
+|     | 0.1  |
+|     | 1    |
+|     | 1    |
+|     | 1    |
+|     | S1   |
+|     | S1   |
+|     | S1   |
+|     | true |
+|     | true |
+|     | true |
+|     |      |
+|     |      |
+|     |      |
++-----+------+
+(45 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A9_B6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u2(c2);
++----+-------+
+| c1 | c2    |
++----+-------+
+| S1 | false |
+| S1 | false |
+| S1 | false |
+| S1 | true  |
+| S1 | true  |
+| S1 | true  |
+| S1 |       |
+| S1 |       |
+| S1 |       |
+| S2 | false |
+| S2 | false |
+| S2 | false |
+| S2 | true  |
+| S2 | true  |
+| S2 | true  |
+| S2 |       |
+| S2 |       |
+| S2 |       |
+|    | false |
+|    | false |
+|    | false |
+|    | true  |
+|    | true  |
+|    | true  |
+|    |       |
+|    |       |
+|    |       |
++----+-------+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A9_B7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
+| S1 |  1 |
+| S1 |  1 |
+| S1 |  1 |
+| S1 |  2 |
+| S1 |  2 |
+| S1 |  2 |
+| S1 |    |
+| S1 |    |
+| S1 |    |
+| S2 |  1 |
+| S2 |  1 |
+| S2 |  1 |
+| S2 |  2 |
+| S2 |  2 |
+| S2 |  2 |
+| S2 |    |
+| S2 |    |
+| S2 |    |
+|    |  1 |
+|    |  1 |
+|    |  1 |
+|    |  2 |
+|    |  2 |
+|    |  2 |
+|    |    |
+|    |    |
+|    |    |
++----+----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A9_B8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u2(c2);
++----+-----+
+| c1 | c2  |
++----+-----+
+| S1 | 0.1 |
+| S1 | 0.1 |
+| S1 | 0.1 |
+| S1 | 0.2 |
+| S1 | 0.2 |
+| S1 | 0.2 |
+| S1 |     |
+| S1 |     |
+| S1 |     |
+| S2 | 0.1 |
+| S2 | 0.1 |
+| S2 | 0.1 |
+| S2 | 0.2 |
+| S2 | 0.2 |
+| S2 | 0.2 |
+| S2 |     |
+| S2 |     |
+| S2 |     |
+|    | 0.1 |
+|    | 0.1 |
+|    | 0.1 |
+|    | 0.2 |
+|    | 0.2 |
+|    | 0.2 |
+|    |     |
+|    |     |
+|    |     |
++----+-----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A9_B9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
+| S1 | S1 |
+| S1 | S1 |
+| S1 | S1 |
+| S1 | S2 |
+| S1 | S2 |
+| S1 | S2 |
+| S1 |    |
+| S1 |    |
+| S1 |    |
+| S2 | S1 |
+| S2 | S1 |
+| S2 | S1 |
+| S2 | S2 |
+| S2 | S2 |
+| S2 | S2 |
+| S2 |    |
+| S2 |    |
+| S2 |    |
+|    | S1 |
+|    | S1 |
+|    | S1 |
+|    | S2 |
+|    | S2 |
+|    | S2 |
+|    |    |
+|    |    |
+|    |    |
++----+----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A9_B10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
+| S1 |    |
+| S1 |    |
+| S1 |    |
+| S1 |    |
+| S1 |    |
+| S1 |    |
+| S1 |    |
+| S1 |    |
+| S1 |    |
+| S2 |    |
+| S2 |    |
+| S2 |    |
+| S2 |    |
+| S2 |    |
+| S2 |    |
+| S2 |    |
+| S2 |    |
+| S2 |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
++----+----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A9_B11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
++----+----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A9_B12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u2(c2);
++----+------+
+| c1 | c2   |
++----+------+
+| S1 | 0.1  |
+| S1 | 0.1  |
+| S1 | 0.1  |
+| S1 | 1    |
+| S1 | 1    |
+| S1 | 1    |
+| S1 | S1   |
+| S1 | S1   |
+| S1 | S1   |
+| S1 | true |
+| S1 | true |
+| S1 | true |
+| S1 |      |
+| S1 |      |
+| S1 |      |
+| S2 | 0.1  |
+| S2 | 0.1  |
+| S2 | 0.1  |
+| S2 | 1    |
+| S2 | 1    |
+| S2 | 1    |
+| S2 | S1   |
+| S2 | S1   |
+| S2 | S1   |
+| S2 | true |
+| S2 | true |
+| S2 | true |
+| S2 |      |
+| S2 |      |
+| S2 |      |
+|    | 0.1  |
+|    | 0.1  |
+|    | 0.1  |
+|    | 1    |
+|    | 1    |
+|    | 1    |
+|    | S1   |
+|    | S1   |
+|    | S1   |
+|    | true |
+|    | true |
+|    | true |
+|    |      |
+|    |      |
+|    |      |
++----+------+
+(45 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A10_B6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u2(c2);
++----+-------+
+| c1 | c2    |
++----+-------+
+|    | false |
+|    | false |
+|    | false |
+|    | false |
+|    | false |
+|    | false |
+|    | false |
+|    | false |
+|    | false |
+|    | true  |
+|    | true  |
+|    | true  |
+|    | true  |
+|    | true  |
+|    | true  |
+|    | true  |
+|    | true  |
+|    | true  |
+|    |       |
+|    |       |
+|    |       |
+|    |       |
+|    |       |
+|    |       |
+|    |       |
+|    |       |
+|    |       |
++----+-------+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A10_B7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
+|    |  1 |
+|    |  1 |
+|    |  1 |
+|    |  1 |
+|    |  1 |
+|    |  1 |
+|    |  1 |
+|    |  1 |
+|    |  1 |
+|    |  2 |
+|    |  2 |
+|    |  2 |
+|    |  2 |
+|    |  2 |
+|    |  2 |
+|    |  2 |
+|    |  2 |
+|    |  2 |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
++----+----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A10_B8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u2(c2);
++----+-----+
+| c1 | c2  |
++----+-----+
+|    | 0.1 |
+|    | 0.1 |
+|    | 0.1 |
+|    | 0.1 |
+|    | 0.1 |
+|    | 0.1 |
+|    | 0.1 |
+|    | 0.1 |
+|    | 0.1 |
+|    | 0.2 |
+|    | 0.2 |
+|    | 0.2 |
+|    | 0.2 |
+|    | 0.2 |
+|    | 0.2 |
+|    | 0.2 |
+|    | 0.2 |
+|    | 0.2 |
+|    |     |
+|    |     |
+|    |     |
+|    |     |
+|    |     |
+|    |     |
+|    |     |
+|    |     |
+|    |     |
++----+-----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A10_B9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
+|    | S1 |
+|    | S1 |
+|    | S1 |
+|    | S1 |
+|    | S1 |
+|    | S1 |
+|    | S1 |
+|    | S1 |
+|    | S1 |
+|    | S2 |
+|    | S2 |
+|    | S2 |
+|    | S2 |
+|    | S2 |
+|    | S2 |
+|    | S2 |
+|    | S2 |
+|    | S2 |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
++----+----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A10_B10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
+|    |    |
++----+----+
+(27 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A10_B11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
++----+----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A10_B12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u2(c2);
++----+------+
+| c1 | c2   |
++----+------+
+|    | 0.1  |
+|    | 0.1  |
+|    | 0.1  |
+|    | 0.1  |
+|    | 0.1  |
+|    | 0.1  |
+|    | 0.1  |
+|    | 0.1  |
+|    | 0.1  |
+|    | 1    |
+|    | 1    |
+|    | 1    |
+|    | 1    |
+|    | 1    |
+|    | 1    |
+|    | 1    |
+|    | 1    |
+|    | 1    |
+|    | S1   |
+|    | S1   |
+|    | S1   |
+|    | S1   |
+|    | S1   |
+|    | S1   |
+|    | S1   |
+|    | S1   |
+|    | S1   |
+|    | true |
+|    | true |
+|    | true |
+|    | true |
+|    | true |
+|    | true |
+|    | true |
+|    | true |
+|    | true |
+|    |      |
+|    |      |
+|    |      |
+|    |      |
+|    |      |
+|    |      |
+|    |      |
+|    |      |
+|    |      |
++----+------+
+(45 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A11_B6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
++----+----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A11_B7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
++----+----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A11_B8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
++----+----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A11_B9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
++----+----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A11_B10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
++----+----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A11_B11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
++----+----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A11_B12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
++----+----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A12_B6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u2(c2);
++------+-------+
+| c1   | c2    |
++------+-------+
+| 0.1  | false |
+| 0.1  | false |
+| 0.1  | false |
+| 0.1  | true  |
+| 0.1  | true  |
+| 0.1  | true  |
+| 0.1  |       |
+| 0.1  |       |
+| 0.1  |       |
+| 1    | false |
+| 1    | false |
+| 1    | false |
+| 1    | true  |
+| 1    | true  |
+| 1    | true  |
+| 1    |       |
+| 1    |       |
+| 1    |       |
+| S1   | false |
+| S1   | false |
+| S1   | false |
+| S1   | true  |
+| S1   | true  |
+| S1   | true  |
+| S1   |       |
+| S1   |       |
+| S1   |       |
+| true | false |
+| true | false |
+| true | false |
+| true | true  |
+| true | true  |
+| true | true  |
+| true |       |
+| true |       |
+| true |       |
+|      | false |
+|      | false |
+|      | false |
+|      | true  |
+|      | true  |
+|      | true  |
+|      |       |
+|      |       |
+|      |       |
++------+-------+
+(45 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A12_B7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u2(c2);
++------+----+
+| c1   | c2 |
++------+----+
+| 0.1  |  1 |
+| 0.1  |  1 |
+| 0.1  |  1 |
+| 0.1  |  2 |
+| 0.1  |  2 |
+| 0.1  |  2 |
+| 0.1  |    |
+| 0.1  |    |
+| 0.1  |    |
+| 1    |  1 |
+| 1    |  1 |
+| 1    |  1 |
+| 1    |  2 |
+| 1    |  2 |
+| 1    |  2 |
+| 1    |    |
+| 1    |    |
+| 1    |    |
+| S1   |  1 |
+| S1   |  1 |
+| S1   |  1 |
+| S1   |  2 |
+| S1   |  2 |
+| S1   |  2 |
+| S1   |    |
+| S1   |    |
+| S1   |    |
+| true |  1 |
+| true |  1 |
+| true |  1 |
+| true |  2 |
+| true |  2 |
+| true |  2 |
+| true |    |
+| true |    |
+| true |    |
+|      |  1 |
+|      |  1 |
+|      |  1 |
+|      |  2 |
+|      |  2 |
+|      |  2 |
+|      |    |
+|      |    |
+|      |    |
++------+----+
+(45 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A12_B8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u2(c2);
++------+-----+
+| c1   | c2  |
++------+-----+
+| 0.1  | 0.1 |
+| 0.1  | 0.1 |
+| 0.1  | 0.1 |
+| 0.1  | 0.2 |
+| 0.1  | 0.2 |
+| 0.1  | 0.2 |
+| 0.1  |     |
+| 0.1  |     |
+| 0.1  |     |
+| 1    | 0.1 |
+| 1    | 0.1 |
+| 1    | 0.1 |
+| 1    | 0.2 |
+| 1    | 0.2 |
+| 1    | 0.2 |
+| 1    |     |
+| 1    |     |
+| 1    |     |
+| S1   | 0.1 |
+| S1   | 0.1 |
+| S1   | 0.1 |
+| S1   | 0.2 |
+| S1   | 0.2 |
+| S1   | 0.2 |
+| S1   |     |
+| S1   |     |
+| S1   |     |
+| true | 0.1 |
+| true | 0.1 |
+| true | 0.1 |
+| true | 0.2 |
+| true | 0.2 |
+| true | 0.2 |
+| true |     |
+| true |     |
+| true |     |
+|      | 0.1 |
+|      | 0.1 |
+|      | 0.1 |
+|      | 0.2 |
+|      | 0.2 |
+|      | 0.2 |
+|      |     |
+|      |     |
+|      |     |
++------+-----+
+(45 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A12_B9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u2(c2);
++------+----+
+| c1   | c2 |
++------+----+
+| 0.1  | S1 |
+| 0.1  | S1 |
+| 0.1  | S1 |
+| 0.1  | S2 |
+| 0.1  | S2 |
+| 0.1  | S2 |
+| 0.1  |    |
+| 0.1  |    |
+| 0.1  |    |
+| 1    | S1 |
+| 1    | S1 |
+| 1    | S1 |
+| 1    | S2 |
+| 1    | S2 |
+| 1    | S2 |
+| 1    |    |
+| 1    |    |
+| 1    |    |
+| S1   | S1 |
+| S1   | S1 |
+| S1   | S1 |
+| S1   | S2 |
+| S1   | S2 |
+| S1   | S2 |
+| S1   |    |
+| S1   |    |
+| S1   |    |
+| true | S1 |
+| true | S1 |
+| true | S1 |
+| true | S2 |
+| true | S2 |
+| true | S2 |
+| true |    |
+| true |    |
+| true |    |
+|      | S1 |
+|      | S1 |
+|      | S1 |
+|      | S2 |
+|      | S2 |
+|      | S2 |
+|      |    |
+|      |    |
+|      |    |
++------+----+
+(45 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A12_B10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u2(c2);
++------+----+
+| c1   | c2 |
++------+----+
+| 0.1  |    |
+| 0.1  |    |
+| 0.1  |    |
+| 0.1  |    |
+| 0.1  |    |
+| 0.1  |    |
+| 0.1  |    |
+| 0.1  |    |
+| 0.1  |    |
+| 1    |    |
+| 1    |    |
+| 1    |    |
+| 1    |    |
+| 1    |    |
+| 1    |    |
+| 1    |    |
+| 1    |    |
+| 1    |    |
+| S1   |    |
+| S1   |    |
+| S1   |    |
+| S1   |    |
+| S1   |    |
+| S1   |    |
+| S1   |    |
+| S1   |    |
+| S1   |    |
+| true |    |
+| true |    |
+| true |    |
+| true |    |
+| true |    |
+| true |    |
+| true |    |
+| true |    |
+| true |    |
+|      |    |
+|      |    |
+|      |    |
+|      |    |
+|      |    |
+|      |    |
+|      |    |
+|      |    |
+|      |    |
++------+----+
+(45 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A12_B11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u2(c2);
++----+----+
+| c1 | c2 |
++----+----+
++----+----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A12_B12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c1,
+       c2
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u1(c1),
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u2(c2);
++------+------+
+| c1   | c2   |
++------+------+
+| 0.1  | 0.1  |
+| 0.1  | 0.1  |
+| 0.1  | 0.1  |
+| 0.1  | 1    |
+| 0.1  | 1    |
+| 0.1  | 1    |
+| 0.1  | S1   |
+| 0.1  | S1   |
+| 0.1  | S1   |
+| 0.1  | true |
+| 0.1  | true |
+| 0.1  | true |
+| 0.1  |      |
+| 0.1  |      |
+| 0.1  |      |
+| 1    | 0.1  |
+| 1    | 0.1  |
+| 1    | 0.1  |
+| 1    | 1    |
+| 1    | 1    |
+| 1    | 1    |
+| 1    | S1   |
+| 1    | S1   |
+| 1    | S1   |
+| 1    | true |
+| 1    | true |
+| 1    | true |
+| 1    |      |
+| 1    |      |
+| 1    |      |
+| S1   | 0.1  |
+| S1   | 0.1  |
+| S1   | 0.1  |
+| S1   | 1    |
+| S1   | 1    |
+| S1   | 1    |
+| S1   | S1   |
+| S1   | S1   |
+| S1   | S1   |
+| S1   | true |
+| S1   | true |
+| S1   | true |
+| S1   |      |
+| S1   |      |
+| S1   |      |
+| true | 0.1  |
+| true | 0.1  |
+| true | 0.1  |
+| true | 1    |
+| true | 1    |
+| true | 1    |
+| true | S1   |
+| true | S1   |
+| true | S1   |
+| true | true |
+| true | true |
+| true | true |
+| true |      |
+| true |      |
+| true |      |
+|      | 0.1  |
+|      | 0.1  |
+|      | 0.1  |
+|      | 1    |
+|      | 1    |
+|      | 1    |
+|      | S1   |
+|      | S1   |
+|      | S1   |
+|      | true |
+|      | true |
+|      | true |
+|      |      |
+|      |      |
+|      |      |
++------+------+
+(75 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY c;
++---+-----+
+| c | cnt |
++---+-----+
+| 0 |   3 |
+| 1 |   3 |
+|   |   3 |
++---+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY s_int,
+         c;
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
+|     1 | 0 |   1 |
+|     1 | 1 |   1 |
+|     1 |   |   1 |
+|     2 | 0 |   1 |
+|     2 | 1 |   1 |
+|     2 |   |   1 |
+|       | 0 |   1 |
+|       | 1 |   1 |
+|       |   |   1 |
++-------+---+-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY s_int;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY GROUPING
+SETS (c);
++---+-----+
+| c | cnt |
++---+-----+
+| 0 |   3 |
+| 1 |   3 |
+|   |   3 |
++---+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY GROUPING
+SETS (s_int,
+      c);
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
+|     1 |   |   3 |
+|     2 |   |   3 |
+|       | 0 |   3 |
+|       | 1 |   3 |
+|       |   |   3 |
+|       |   |   3 |
++-------+---+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY GROUPING
+SETS (s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY rollup(c);
++---+-----+
+| c | cnt |
++---+-----+
+| 0 |   3 |
+| 1 |   3 |
+|   |   3 |
+|   |   9 |
++---+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY rollup(s_int, c);
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
+|     1 | 0 |   1 |
+|     1 | 1 |   1 |
+|     1 |   |   1 |
+|     1 |   |   3 |
+|     2 | 0 |   1 |
+|     2 | 1 |   1 |
+|     2 |   |   1 |
+|     2 |   |   3 |
+|       | 0 |   1 |
+|       | 1 |   1 |
+|       |   |   1 |
+|       |   |   3 |
+|       |   |   9 |
++-------+---+-----+
+(13 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY rollup(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY cube(c);
++---+-----+
+| c | cnt |
++---+-----+
+| 0 |   3 |
+| 1 |   3 |
+|   |   3 |
+|   |   9 |
++---+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY cube(s_int, c);
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
+|     1 | 0 |   1 |
+|     1 | 1 |   1 |
+|     1 |   |   1 |
+|     1 |   |   3 |
+|     2 | 0 |   1 |
+|     2 | 1 |   1 |
+|     2 |   |   1 |
+|     2 |   |   3 |
+|       | 0 |   1 |
+|       | 0 |   3 |
+|       | 1 |   1 |
+|       | 1 |   3 |
+|       |   |   1 |
+|       |   |   3 |
+|       |   |   3 |
+|       |   |   9 |
++-------+---+-----+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY cube(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY c
+HAVING c = 0;
++---+-----+
+| c | cnt |
++---+-----+
+| 0 |   3 |
++---+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY s_int
+HAVING s_int=1;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
++-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY c;
++-------+-----+
+| c     | cnt |
++-------+-----+
+| false |   3 |
+| true  |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY s_int,
+         c;
++-------+-------+-----+
+| s_int | c     | cnt |
++-------+-------+-----+
+|     1 | false |   1 |
+|     1 | true  |   1 |
+|     1 |       |   1 |
+|     2 | false |   1 |
+|     2 | true  |   1 |
+|     2 |       |   1 |
+|       | false |   1 |
+|       | true  |   1 |
+|       |       |   1 |
++-------+-------+-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY s_int;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY GROUPING
+SETS (c);
++-------+-----+
+| c     | cnt |
++-------+-----+
+| false |   3 |
+| true  |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY GROUPING
+SETS (s_int,
+      c);
++-------+-------+-----+
+| s_int | c     | cnt |
++-------+-------+-----+
+|     1 |       |   3 |
+|     2 |       |   3 |
+|       | false |   3 |
+|       | true  |   3 |
+|       |       |   3 |
+|       |       |   3 |
++-------+-------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY GROUPING
+SETS (s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY rollup(c);
++-------+-----+
+| c     | cnt |
++-------+-----+
+| false |   3 |
+| true  |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY rollup(s_int, c);
++-------+-------+-----+
+| s_int | c     | cnt |
++-------+-------+-----+
+|     1 | false |   1 |
+|     1 | true  |   1 |
+|     1 |       |   1 |
+|     1 |       |   3 |
+|     2 | false |   1 |
+|     2 | true  |   1 |
+|     2 |       |   1 |
+|     2 |       |   3 |
+|       | false |   1 |
+|       | true  |   1 |
+|       |       |   1 |
+|       |       |   3 |
+|       |       |   9 |
++-------+-------+-----+
+(13 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY rollup(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY cube(c);
++-------+-----+
+| c     | cnt |
++-------+-----+
+| false |   3 |
+| true  |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY cube(s_int, c);
++-------+-------+-----+
+| s_int | c     | cnt |
++-------+-------+-----+
+|     1 | false |   1 |
+|     1 | true  |   1 |
+|     1 |       |   1 |
+|     1 |       |   3 |
+|     2 | false |   1 |
+|     2 | true  |   1 |
+|     2 |       |   1 |
+|     2 |       |   3 |
+|       | false |   1 |
+|       | false |   3 |
+|       | true  |   1 |
+|       | true  |   3 |
+|       |       |   1 |
+|       |       |   3 |
+|       |       |   3 |
+|       |       |   9 |
++-------+-------+-----+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY cube(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY c
+HAVING c IS FALSE;
++-------+-----+
+| c     | cnt |
++-------+-----+
+| false |   3 |
++-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY s_int
+HAVING s_int=1;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
++-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY c;
++---+-----+
+| c | cnt |
++---+-----+
+| 1 |   3 |
+| 2 |   3 |
+|   |   3 |
++---+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY s_int,
+         c;
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
+|     1 | 1 |   1 |
+|     1 | 2 |   1 |
+|     1 |   |   1 |
+|     2 | 1 |   1 |
+|     2 | 2 |   1 |
+|     2 |   |   1 |
+|       | 1 |   1 |
+|       | 2 |   1 |
+|       |   |   1 |
++-------+---+-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY s_int;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY GROUPING
+SETS (c);
++---+-----+
+| c | cnt |
++---+-----+
+| 1 |   3 |
+| 2 |   3 |
+|   |   3 |
++---+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY GROUPING
+SETS (s_int,
+      c);
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
+|     1 |   |   3 |
+|     2 |   |   3 |
+|       | 1 |   3 |
+|       | 2 |   3 |
+|       |   |   3 |
+|       |   |   3 |
++-------+---+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY GROUPING
+SETS (s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY rollup(c);
++---+-----+
+| c | cnt |
++---+-----+
+| 1 |   3 |
+| 2 |   3 |
+|   |   3 |
+|   |   9 |
++---+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY rollup(s_int, c);
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
+|     1 | 1 |   1 |
+|     1 | 2 |   1 |
+|     1 |   |   1 |
+|     1 |   |   3 |
+|     2 | 1 |   1 |
+|     2 | 2 |   1 |
+|     2 |   |   1 |
+|     2 |   |   3 |
+|       | 1 |   1 |
+|       | 2 |   1 |
+|       |   |   1 |
+|       |   |   3 |
+|       |   |   9 |
++-------+---+-----+
+(13 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY rollup(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY cube(c);
++---+-----+
+| c | cnt |
++---+-----+
+| 1 |   3 |
+| 2 |   3 |
+|   |   3 |
+|   |   9 |
++---+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY cube(s_int, c);
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
+|     1 | 1 |   1 |
+|     1 | 2 |   1 |
+|     1 |   |   1 |
+|     1 |   |   3 |
+|     2 | 1 |   1 |
+|     2 | 2 |   1 |
+|     2 |   |   1 |
+|     2 |   |   3 |
+|       | 1 |   1 |
+|       | 1 |   3 |
+|       | 2 |   1 |
+|       | 2 |   3 |
+|       |   |   1 |
+|       |   |   3 |
+|       |   |   3 |
+|       |   |   9 |
++-------+---+-----+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY cube(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY c
+HAVING c = 1;
++---+-----+
+| c | cnt |
++---+-----+
+| 1 |   3 |
++---+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY s_int
+HAVING s_int=1;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
++-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY c;
++---+-----+
+| c | cnt |
++---+-----+
+| 1 |   3 |
+| 2 |   3 |
+|   |   3 |
++---+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY s_int,
+         c;
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
+|     1 | 1 |   1 |
+|     1 | 2 |   1 |
+|     1 |   |   1 |
+|     2 | 1 |   1 |
+|     2 | 2 |   1 |
+|     2 |   |   1 |
+|       | 1 |   1 |
+|       | 2 |   1 |
+|       |   |   1 |
++-------+---+-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY s_int;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY GROUPING
+SETS (c);
++---+-----+
+| c | cnt |
++---+-----+
+| 1 |   3 |
+| 2 |   3 |
+|   |   3 |
++---+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY GROUPING
+SETS (s_int,
+      c);
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
+|     1 |   |   3 |
+|     2 |   |   3 |
+|       | 1 |   3 |
+|       | 2 |   3 |
+|       |   |   3 |
+|       |   |   3 |
++-------+---+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY GROUPING
+SETS (s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY rollup(c);
++---+-----+
+| c | cnt |
++---+-----+
+| 1 |   3 |
+| 2 |   3 |
+|   |   3 |
+|   |   9 |
++---+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY rollup(s_int, c);
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
+|     1 | 1 |   1 |
+|     1 | 2 |   1 |
+|     1 |   |   1 |
+|     1 |   |   3 |
+|     2 | 1 |   1 |
+|     2 | 2 |   1 |
+|     2 |   |   1 |
+|     2 |   |   3 |
+|       | 1 |   1 |
+|       | 2 |   1 |
+|       |   |   1 |
+|       |   |   3 |
+|       |   |   9 |
++-------+---+-----+
+(13 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY rollup(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY cube(c);
++---+-----+
+| c | cnt |
++---+-----+
+| 1 |   3 |
+| 2 |   3 |
+|   |   3 |
+|   |   9 |
++---+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY cube(s_int, c);
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
+|     1 | 1 |   1 |
+|     1 | 2 |   1 |
+|     1 |   |   1 |
+|     1 |   |   3 |
+|     2 | 1 |   1 |
+|     2 | 2 |   1 |
+|     2 |   |   1 |
+|     2 |   |   3 |
+|       | 1 |   1 |
+|       | 1 |   3 |
+|       | 2 |   1 |
+|       | 2 |   3 |
+|       |   |   1 |
+|       |   |   3 |
+|       |   |   3 |
+|       |   |   9 |
++-------+---+-----+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY cube(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY c
+HAVING c = 1;
++---+-----+
+| c | cnt |
++---+-----+
+| 1 |   3 |
++---+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY s_int
+HAVING s_int=1;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
++-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY c;
++-----+-----+
+| c   | cnt |
++-----+-----+
+| 0.1 |   3 |
+| 0.2 |   3 |
+|     |   3 |
++-----+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY s_int,
+         c;
++-------+-----+-----+
+| s_int | c   | cnt |
++-------+-----+-----+
+|     1 | 0.1 |   1 |
+|     1 | 0.2 |   1 |
+|     1 |     |   1 |
+|     2 | 0.1 |   1 |
+|     2 | 0.2 |   1 |
+|     2 |     |   1 |
+|       | 0.1 |   1 |
+|       | 0.2 |   1 |
+|       |     |   1 |
++-------+-----+-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY s_int;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY GROUPING
+SETS (c);
++-----+-----+
+| c   | cnt |
++-----+-----+
+| 0.1 |   3 |
+| 0.2 |   3 |
+|     |   3 |
++-----+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY GROUPING
+SETS (s_int,
+      c);
++-------+-----+-----+
+| s_int | c   | cnt |
++-------+-----+-----+
+|     1 |     |   3 |
+|     2 |     |   3 |
+|       | 0.1 |   3 |
+|       | 0.2 |   3 |
+|       |     |   3 |
+|       |     |   3 |
++-------+-----+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY GROUPING
+SETS (s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY rollup(c);
++-----+-----+
+| c   | cnt |
++-----+-----+
+| 0.1 |   3 |
+| 0.2 |   3 |
+|     |   3 |
+|     |   9 |
++-----+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY rollup(s_int, c);
++-------+-----+-----+
+| s_int | c   | cnt |
++-------+-----+-----+
+|     1 | 0.1 |   1 |
+|     1 | 0.2 |   1 |
+|     1 |     |   1 |
+|     1 |     |   3 |
+|     2 | 0.1 |   1 |
+|     2 | 0.2 |   1 |
+|     2 |     |   1 |
+|     2 |     |   3 |
+|       | 0.1 |   1 |
+|       | 0.2 |   1 |
+|       |     |   1 |
+|       |     |   3 |
+|       |     |   9 |
++-------+-----+-----+
+(13 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY rollup(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY cube(c);
++-----+-----+
+| c   | cnt |
++-----+-----+
+| 0.1 |   3 |
+| 0.2 |   3 |
+|     |   3 |
+|     |   9 |
++-----+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY cube(s_int, c);
++-------+-----+-----+
+| s_int | c   | cnt |
++-------+-----+-----+
+|     1 | 0.1 |   1 |
+|     1 | 0.2 |   1 |
+|     1 |     |   1 |
+|     1 |     |   3 |
+|     2 | 0.1 |   1 |
+|     2 | 0.2 |   1 |
+|     2 |     |   1 |
+|     2 |     |   3 |
+|       | 0.1 |   1 |
+|       | 0.1 |   3 |
+|       | 0.2 |   1 |
+|       | 0.2 |   3 |
+|       |     |   1 |
+|       |     |   3 |
+|       |     |   3 |
+|       |     |   9 |
++-------+-----+-----+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY cube(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY c
+HAVING c = 0.1;
++-----+-----+
+| c   | cnt |
++-----+-----+
+| 0.1 |   3 |
++-----+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY s_int
+HAVING s_int=1;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
++-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY c;
++-----+-----+
+| c   | cnt |
++-----+-----+
+| 0.1 |   3 |
+| 0.2 |   3 |
+|     |   3 |
++-----+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY s_int,
+         c;
++-------+-----+-----+
+| s_int | c   | cnt |
++-------+-----+-----+
+|     1 | 0.1 |   1 |
+|     1 | 0.2 |   1 |
+|     1 |     |   1 |
+|     2 | 0.1 |   1 |
+|     2 | 0.2 |   1 |
+|     2 |     |   1 |
+|       | 0.1 |   1 |
+|       | 0.2 |   1 |
+|       |     |   1 |
++-------+-----+-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY s_int;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY GROUPING
+SETS (c);
++-----+-----+
+| c   | cnt |
++-----+-----+
+| 0.1 |   3 |
+| 0.2 |   3 |
+|     |   3 |
++-----+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY GROUPING
+SETS (s_int,
+      c);
++-------+-----+-----+
+| s_int | c   | cnt |
++-------+-----+-----+
+|     1 |     |   3 |
+|     2 |     |   3 |
+|       | 0.1 |   3 |
+|       | 0.2 |   3 |
+|       |     |   3 |
+|       |     |   3 |
++-------+-----+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY GROUPING
+SETS (s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY rollup(c);
++-----+-----+
+| c   | cnt |
++-----+-----+
+| 0.1 |   3 |
+| 0.2 |   3 |
+|     |   3 |
+|     |   9 |
++-----+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY rollup(s_int, c);
++-------+-----+-----+
+| s_int | c   | cnt |
++-------+-----+-----+
+|     1 | 0.1 |   1 |
+|     1 | 0.2 |   1 |
+|     1 |     |   1 |
+|     1 |     |   3 |
+|     2 | 0.1 |   1 |
+|     2 | 0.2 |   1 |
+|     2 |     |   1 |
+|     2 |     |   3 |
+|       | 0.1 |   1 |
+|       | 0.2 |   1 |
+|       |     |   1 |
+|       |     |   3 |
+|       |     |   9 |
++-------+-----+-----+
+(13 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY rollup(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY cube(c);
++-----+-----+
+| c   | cnt |
++-----+-----+
+| 0.1 |   3 |
+| 0.2 |   3 |
+|     |   3 |
+|     |   9 |
++-----+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY cube(s_int, c);
++-------+-----+-----+
+| s_int | c   | cnt |
++-------+-----+-----+
+|     1 | 0.1 |   1 |
+|     1 | 0.2 |   1 |
+|     1 |     |   1 |
+|     1 |     |   3 |
+|     2 | 0.1 |   1 |
+|     2 | 0.2 |   1 |
+|     2 |     |   1 |
+|     2 |     |   3 |
+|       | 0.1 |   1 |
+|       | 0.1 |   3 |
+|       | 0.2 |   1 |
+|       | 0.2 |   3 |
+|       |     |   1 |
+|       |     |   3 |
+|       |     |   3 |
+|       |     |   9 |
++-------+-----+-----+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY cube(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY c
+HAVING c = 0.1;
++-----+-----+
+| c   | cnt |
++-----+-----+
+| 0.1 |   3 |
++-----+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY s_int
+HAVING s_int=1;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
++-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY c;
++----+-----+
+| c  | cnt |
++----+-----+
+| S1 |   3 |
+| S2 |   3 |
+|    |   3 |
++----+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY s_int,
+         c;
++-------+----+-----+
+| s_int | c  | cnt |
++-------+----+-----+
+|     1 | S1 |   1 |
+|     1 | S2 |   1 |
+|     1 |    |   1 |
+|     2 | S1 |   1 |
+|     2 | S2 |   1 |
+|     2 |    |   1 |
+|       | S1 |   1 |
+|       | S2 |   1 |
+|       |    |   1 |
++-------+----+-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY s_int;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY GROUPING
+SETS (c);
++----+-----+
+| c  | cnt |
++----+-----+
+| S1 |   3 |
+| S2 |   3 |
+|    |   3 |
++----+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY GROUPING
+SETS (s_int,
+      c);
++-------+----+-----+
+| s_int | c  | cnt |
++-------+----+-----+
+|     1 |    |   3 |
+|     2 |    |   3 |
+|       | S1 |   3 |
+|       | S2 |   3 |
+|       |    |   3 |
+|       |    |   3 |
++-------+----+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY GROUPING
+SETS (s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY rollup(c);
++----+-----+
+| c  | cnt |
++----+-----+
+| S1 |   3 |
+| S2 |   3 |
+|    |   3 |
+|    |   9 |
++----+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY rollup(s_int, c);
++-------+----+-----+
+| s_int | c  | cnt |
++-------+----+-----+
+|     1 | S1 |   1 |
+|     1 | S2 |   1 |
+|     1 |    |   1 |
+|     1 |    |   3 |
+|     2 | S1 |   1 |
+|     2 | S2 |   1 |
+|     2 |    |   1 |
+|     2 |    |   3 |
+|       | S1 |   1 |
+|       | S2 |   1 |
+|       |    |   1 |
+|       |    |   3 |
+|       |    |   9 |
++-------+----+-----+
+(13 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY rollup(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY cube(c);
++----+-----+
+| c  | cnt |
++----+-----+
+| S1 |   3 |
+| S2 |   3 |
+|    |   3 |
+|    |   9 |
++----+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY cube(s_int, c);
++-------+----+-----+
+| s_int | c  | cnt |
++-------+----+-----+
+|     1 | S1 |   1 |
+|     1 | S2 |   1 |
+|     1 |    |   1 |
+|     1 |    |   3 |
+|     2 | S1 |   1 |
+|     2 | S2 |   1 |
+|     2 |    |   1 |
+|     2 |    |   3 |
+|       | S1 |   1 |
+|       | S1 |   3 |
+|       | S2 |   1 |
+|       | S2 |   3 |
+|       |    |   1 |
+|       |    |   3 |
+|       |    |   3 |
+|       |    |   9 |
++-------+----+-----+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY cube(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY c
+HAVING c = 'S1';
++----+-----+
+| c  | cnt |
++----+-----+
+| S1 |   3 |
++----+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY s_int
+HAVING s_int=1;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
++-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A8_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY c;
++----+-----+
+| c  | cnt |
++----+-----+
+| S1 |   3 |
+| S2 |   3 |
+|    |   3 |
++----+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A8_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int,
+         c;
++-------+----+-----+
+| s_int | c  | cnt |
++-------+----+-----+
+|     1 | S1 |   1 |
+|     1 | S2 |   1 |
+|     1 |    |   1 |
+|     2 | S1 |   1 |
+|     2 | S2 |   1 |
+|     2 |    |   1 |
+|       | S1 |   1 |
+|       | S2 |   1 |
+|       |    |   1 |
++-------+----+-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A8_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A8_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY GROUPING
+SETS (c);
++----+-----+
+| c  | cnt |
++----+-----+
+| S1 |   3 |
+| S2 |   3 |
+|    |   3 |
++----+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A8_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY GROUPING
+SETS (s_int,
+      c);
++-------+----+-----+
+| s_int | c  | cnt |
++-------+----+-----+
+|     1 |    |   3 |
+|     2 |    |   3 |
+|       | S1 |   3 |
+|       | S2 |   3 |
+|       |    |   3 |
+|       |    |   3 |
++-------+----+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A8_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY GROUPING
+SETS (s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A8_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY rollup(c);
++----+-----+
+| c  | cnt |
++----+-----+
+| S1 |   3 |
+| S2 |   3 |
+|    |   3 |
+|    |   9 |
++----+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A8_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY rollup(s_int, c);
++-------+----+-----+
+| s_int | c  | cnt |
++-------+----+-----+
+|     1 | S1 |   1 |
+|     1 | S2 |   1 |
+|     1 |    |   1 |
+|     1 |    |   3 |
+|     2 | S1 |   1 |
+|     2 | S2 |   1 |
+|     2 |    |   1 |
+|     2 |    |   3 |
+|       | S1 |   1 |
+|       | S2 |   1 |
+|       |    |   1 |
+|       |    |   3 |
+|       |    |   9 |
++-------+----+-----+
+(13 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A8_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY rollup(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A8_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY cube(c);
++----+-----+
+| c  | cnt |
++----+-----+
+| S1 |   3 |
+| S2 |   3 |
+|    |   3 |
+|    |   9 |
++----+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A8_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY cube(s_int, c);
++-------+----+-----+
+| s_int | c  | cnt |
++-------+----+-----+
+|     1 | S1 |   1 |
+|     1 | S2 |   1 |
+|     1 |    |   1 |
+|     1 |    |   3 |
+|     2 | S1 |   1 |
+|     2 | S2 |   1 |
+|     2 |    |   1 |
+|     2 |    |   3 |
+|       | S1 |   1 |
+|       | S1 |   3 |
+|       | S2 |   1 |
+|       | S2 |   3 |
+|       |    |   1 |
+|       |    |   3 |
+|       |    |   3 |
+|       |    |   9 |
++-------+----+-----+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A8_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY cube(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A8_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY c
+HAVING c = 'S1';
++----+-----+
+| c  | cnt |
++----+-----+
+| S1 |   3 |
++----+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A8_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int
+HAVING s_int=1;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
++-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A9_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY c;
++------+-----+
+| c    | cnt |
++------+-----+
+| 0.1  |   3 |
+| 1    |   3 |
+| S1   |   3 |
+| true |   3 |
+|      |   3 |
++------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A9_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY s_int,
+         c;
++-------+------+-----+
+| s_int | c    | cnt |
++-------+------+-----+
+|     1 | 0.1  |   1 |
+|     1 | 1    |   1 |
+|     1 | S1   |   1 |
+|     1 | true |   1 |
+|     1 |      |   1 |
+|     2 | 0.1  |   1 |
+|     2 | 1    |   1 |
+|     2 | S1   |   1 |
+|     2 | true |   1 |
+|     2 |      |   1 |
+|       | 0.1  |   1 |
+|       | 1    |   1 |
+|       | S1   |   1 |
+|       | true |   1 |
+|       |      |   1 |
++-------+------+-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A9_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY s_int;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   5 |
+|     2 |   5 |
+|       |   5 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A9_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY GROUPING
+SETS (c);
++------+-----+
+| c    | cnt |
++------+-----+
+| 0.1  |   3 |
+| 1    |   3 |
+| S1   |   3 |
+| true |   3 |
+|      |   3 |
++------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A9_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY GROUPING
+SETS (s_int,
+      c);
++-------+------+-----+
+| s_int | c    | cnt |
++-------+------+-----+
+|     1 |      |   5 |
+|     2 |      |   5 |
+|       | 0.1  |   3 |
+|       | 1    |   3 |
+|       | S1   |   3 |
+|       | true |   3 |
+|       |      |   3 |
+|       |      |   5 |
++-------+------+-----+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A9_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY GROUPING
+SETS (s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   5 |
+|     2 |   5 |
+|       |   5 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A9_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY rollup(c);
++------+-----+
+| c    | cnt |
++------+-----+
+| 0.1  |   3 |
+| 1    |   3 |
+| S1   |   3 |
+| true |   3 |
+|      |  15 |
+|      |   3 |
++------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A9_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY rollup(s_int, c);
++-------+------+-----+
+| s_int | c    | cnt |
++-------+------+-----+
+|     1 | 0.1  |   1 |
+|     1 | 1    |   1 |
+|     1 | S1   |   1 |
+|     1 | true |   1 |
+|     1 |      |   1 |
+|     1 |      |   5 |
+|     2 | 0.1  |   1 |
+|     2 | 1    |   1 |
+|     2 | S1   |   1 |
+|     2 | true |   1 |
+|     2 |      |   1 |
+|     2 |      |   5 |
+|       | 0.1  |   1 |
+|       | 1    |   1 |
+|       | S1   |   1 |
+|       | true |   1 |
+|       |      |   1 |
+|       |      |  15 |
+|       |      |   5 |
++-------+------+-----+
+(19 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A9_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY rollup(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   5 |
+|     2 |   5 |
+|       |  15 |
+|       |   5 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A9_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY cube(c);
++------+-----+
+| c    | cnt |
++------+-----+
+| 0.1  |   3 |
+| 1    |   3 |
+| S1   |   3 |
+| true |   3 |
+|      |  15 |
+|      |   3 |
++------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A9_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY cube(s_int, c);
++-------+------+-----+
+| s_int | c    | cnt |
++-------+------+-----+
+|     1 | 0.1  |   1 |
+|     1 | 1    |   1 |
+|     1 | S1   |   1 |
+|     1 | true |   1 |
+|     1 |      |   1 |
+|     1 |      |   5 |
+|     2 | 0.1  |   1 |
+|     2 | 1    |   1 |
+|     2 | S1   |   1 |
+|     2 | true |   1 |
+|     2 |      |   1 |
+|     2 |      |   5 |
+|       | 0.1  |   1 |
+|       | 0.1  |   3 |
+|       | 1    |   1 |
+|       | 1    |   3 |
+|       | S1   |   1 |
+|       | S1   |   3 |
+|       | true |   1 |
+|       | true |   3 |
+|       |      |   1 |
+|       |      |  15 |
+|       |      |   3 |
+|       |      |   5 |
++-------+------+-----+
+(24 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A9_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY cube(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   5 |
+|     2 |   5 |
+|       |  15 |
+|       |   5 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A9_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY c
+HAVING c = 'S1';
++----+-----+
+| c  | cnt |
++----+-----+
+| S1 |   3 |
++----+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A9_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY s_int
+HAVING s_int=1;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   5 |
++-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A10_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY c;
++------+-----+
+| c    | cnt |
++------+-----+
+| 0.1  |   3 |
+| 1    |   3 |
+| S1   |   3 |
+| true |   3 |
+|      |   3 |
++------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A10_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int,
+         c;
++-------+------+-----+
+| s_int | c    | cnt |
++-------+------+-----+
+|     1 | 0.1  |   1 |
+|     1 | 1    |   1 |
+|     1 | S1   |   1 |
+|     1 | true |   1 |
+|     1 |      |   1 |
+|     2 | 0.1  |   1 |
+|     2 | 1    |   1 |
+|     2 | S1   |   1 |
+|     2 | true |   1 |
+|     2 |      |   1 |
+|       | 0.1  |   1 |
+|       | 1    |   1 |
+|       | S1   |   1 |
+|       | true |   1 |
+|       |      |   1 |
++-------+------+-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A10_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   5 |
+|     2 |   5 |
+|       |   5 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A10_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY GROUPING
+SETS (c);
++------+-----+
+| c    | cnt |
++------+-----+
+| 0.1  |   3 |
+| 1    |   3 |
+| S1   |   3 |
+| true |   3 |
+|      |   3 |
++------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A10_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY GROUPING
+SETS (s_int,
+      c);
++-------+------+-----+
+| s_int | c    | cnt |
++-------+------+-----+
+|     1 |      |   5 |
+|     2 |      |   5 |
+|       | 0.1  |   3 |
+|       | 1    |   3 |
+|       | S1   |   3 |
+|       | true |   3 |
+|       |      |   3 |
+|       |      |   5 |
++-------+------+-----+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A10_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY GROUPING
+SETS (s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   5 |
+|     2 |   5 |
+|       |   5 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A10_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY rollup(c);
++------+-----+
+| c    | cnt |
++------+-----+
+| 0.1  |   3 |
+| 1    |   3 |
+| S1   |   3 |
+| true |   3 |
+|      |  15 |
+|      |   3 |
++------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A10_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY rollup(s_int, c);
++-------+------+-----+
+| s_int | c    | cnt |
++-------+------+-----+
+|     1 | 0.1  |   1 |
+|     1 | 1    |   1 |
+|     1 | S1   |   1 |
+|     1 | true |   1 |
+|     1 |      |   1 |
+|     1 |      |   5 |
+|     2 | 0.1  |   1 |
+|     2 | 1    |   1 |
+|     2 | S1   |   1 |
+|     2 | true |   1 |
+|     2 |      |   1 |
+|     2 |      |   5 |
+|       | 0.1  |   1 |
+|       | 1    |   1 |
+|       | S1   |   1 |
+|       | true |   1 |
+|       |      |   1 |
+|       |      |  15 |
+|       |      |   5 |
++-------+------+-----+
+(19 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A10_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY rollup(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   5 |
+|     2 |   5 |
+|       |  15 |
+|       |   5 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A10_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY cube(c);
++------+-----+
+| c    | cnt |
++------+-----+
+| 0.1  |   3 |
+| 1    |   3 |
+| S1   |   3 |
+| true |   3 |
+|      |  15 |
+|      |   3 |
++------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A10_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY cube(s_int, c);
++-------+------+-----+
+| s_int | c    | cnt |
++-------+------+-----+
+|     1 | 0.1  |   1 |
+|     1 | 1    |   1 |
+|     1 | S1   |   1 |
+|     1 | true |   1 |
+|     1 |      |   1 |
+|     1 |      |   5 |
+|     2 | 0.1  |   1 |
+|     2 | 1    |   1 |
+|     2 | S1   |   1 |
+|     2 | true |   1 |
+|     2 |      |   1 |
+|     2 |      |   5 |
+|       | 0.1  |   1 |
+|       | 0.1  |   3 |
+|       | 1    |   1 |
+|       | 1    |   3 |
+|       | S1   |   1 |
+|       | S1   |   3 |
+|       | true |   1 |
+|       | true |   3 |
+|       |      |   1 |
+|       |      |  15 |
+|       |      |   3 |
+|       |      |   5 |
++-------+------+-----+
+(24 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A10_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY cube(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   5 |
+|     2 |   5 |
+|       |  15 |
+|       |   5 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A10_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY c
+HAVING c = 'S1';
++----+-----+
+| c  | cnt |
++----+-----+
+| S1 |   3 |
++----+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A10_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int
+HAVING s_int=1;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   5 |
++-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A11_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY c;
++---+-----+
+| c | cnt |
++---+-----+
+|   |   9 |
++---+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A11_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int,
+         c;
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
+|     1 |   |   3 |
+|     2 |   |   3 |
+|       |   |   3 |
++-------+---+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A11_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A11_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY GROUPING
+SETS (c);
++---+-----+
+| c | cnt |
++---+-----+
+|   |   9 |
++---+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A11_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY GROUPING
+SETS (s_int,
+      c);
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
+|     1 |   |   3 |
+|     2 |   |   3 |
+|       |   |   3 |
+|       |   |   9 |
++-------+---+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A11_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY GROUPING
+SETS (s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A11_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY rollup(c);
++---+-----+
+| c | cnt |
++---+-----+
+|   |   9 |
+|   |   9 |
++---+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A11_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY rollup(s_int, c);
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
+|     1 |   |   3 |
+|     1 |   |   3 |
+|     2 |   |   3 |
+|     2 |   |   3 |
+|       |   |   3 |
+|       |   |   3 |
+|       |   |   9 |
++-------+---+-----+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A11_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY rollup(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A11_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY cube(c);
++---+-----+
+| c | cnt |
++---+-----+
+|   |   9 |
+|   |   9 |
++---+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A11_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY cube(s_int, c);
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
+|     1 |   |   3 |
+|     1 |   |   3 |
+|     2 |   |   3 |
+|     2 |   |   3 |
+|       |   |   3 |
+|       |   |   3 |
+|       |   |   9 |
+|       |   |   9 |
++-------+---+-----+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A11_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY cube(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
+|     2 |   3 |
+|       |   3 |
+|       |   9 |
++-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A11_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY c
+HAVING c IS NULL;
++---+-----+
+| c | cnt |
++---+-----+
+|   |   9 |
++---+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A11_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int
+HAVING s_int=1;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     1 |   3 |
++-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A12_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY c;
++---+-----+
+| c | cnt |
++---+-----+
++---+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A12_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int,
+         c;
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
++-------+---+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A12_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int;
++-------+-----+
+| s_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A12_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY GROUPING
+SETS (c);
++---+-----+
+| c | cnt |
++---+-----+
++---+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A12_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY GROUPING
+SETS (s_int,
+      c);
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
++-------+---+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A12_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY GROUPING
+SETS (s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A12_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY rollup(c);
++---+-----+
+| c | cnt |
++---+-----+
++---+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A12_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY rollup(s_int, c);
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
++-------+---+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A12_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY rollup(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A12_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY cube(c);
++---+-----+
+| c | cnt |
++---+-----+
++---+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A12_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY cube(s_int, c);
++-------+---+-----+
+| s_int | c | cnt |
++-------+---+-----+
++-------+---+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A12_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY cube(s_int);
++-------+-----+
+| s_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A12_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY c
+HAVING c = 1;
++---+-----+
+| c | cnt |
++---+-----+
++---+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A12_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int
+HAVING s_int=1;
++-------+-----+
+| s_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY c
+ORDER BY c ASC;
++---+-----+
+| c | cnt |
++---+-----+
+|   |   3 |
+| 0 |   3 |
+| 1 |   3 |
++---+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY c
+ORDER BY 1 DESC;
++---+-----+
+| c | cnt |
++---+-----+
+| 1 |   3 |
+| 0 |   3 |
+|   |   3 |
++---+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+ORDER BY c ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   ORDER BY c ASC);
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+| 1 |
+|   |
+|   |
+|   |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   ORDER BY 1 DESC);
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+| 1 |
+|   |
+|   |
+|   |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY __time
+ORDER BY __time ASC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |   3 |
+| 2022-02-01 00:00:00.000 |   3 |
+| 2022-03-01 00:00:00.000 |   3 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY __time
+ORDER BY __time DESC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-03-01 00:00:00.000 |   3 |
+| 2022-02-01 00:00:00.000 |   3 |
+| 2022-01-01 00:00:00.000 |   3 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+ORDER BY __time ASC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+ORDER BY 1 DESC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   ORDER BY __time ASC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   ORDER BY 1 DESC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY s_int
+ORDER BY s_int ASC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|       |   3 |
+|     1 |   3 |
+|     2 |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+GROUP BY s_int
+ORDER BY 1 DESC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     2 |   3 |
+|     1 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+ORDER BY s_int ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   ORDER BY s_int ASC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY c
+ORDER BY c ASC;
++-------+-----+
+| c     | cnt |
++-------+-----+
+|       |   3 |
+| false |   3 |
+| true  |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY c
+ORDER BY 1 DESC;
++-------+-----+
+| c     | cnt |
++-------+-----+
+| true  |   3 |
+| false |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+ORDER BY c ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+   ORDER BY c ASC);
++-------+
+| c     |
++-------+
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| c     |
++-------+
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY __time
+ORDER BY __time ASC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |   3 |
+| 2022-02-01 00:00:00.000 |   3 |
+| 2022-03-01 00:00:00.000 |   3 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY __time
+ORDER BY __time DESC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-03-01 00:00:00.000 |   3 |
+| 2022-02-01 00:00:00.000 |   3 |
+| 2022-01-01 00:00:00.000 |   3 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+ORDER BY __time ASC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+ORDER BY 1 DESC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+   ORDER BY __time ASC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+   ORDER BY 1 DESC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY s_int
+ORDER BY s_int ASC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|       |   3 |
+|     1 |   3 |
+|     2 |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+GROUP BY s_int
+ORDER BY 1 DESC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     2 |   3 |
+|     1 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+ORDER BY s_int ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+   ORDER BY s_int ASC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY c
+ORDER BY c ASC;
++---+-----+
+| c | cnt |
++---+-----+
+|   |   3 |
+| 1 |   3 |
+| 2 |   3 |
++---+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY c
+ORDER BY 1 DESC;
++---+-----+
+| c | cnt |
++---+-----+
+| 2 |   3 |
+| 1 |   3 |
+|   |   3 |
++---+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+ORDER BY c ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   ORDER BY c ASC);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+|   |
+|   |
+|   |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   ORDER BY 1 DESC);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+|   |
+|   |
+|   |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY __time
+ORDER BY __time ASC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |   3 |
+| 2022-02-01 00:00:00.000 |   3 |
+| 2022-03-01 00:00:00.000 |   3 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY __time
+ORDER BY __time DESC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-03-01 00:00:00.000 |   3 |
+| 2022-02-01 00:00:00.000 |   3 |
+| 2022-01-01 00:00:00.000 |   3 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+ORDER BY __time ASC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+ORDER BY 1 DESC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   ORDER BY __time ASC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   ORDER BY 1 DESC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY s_int
+ORDER BY s_int ASC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|       |   3 |
+|     1 |   3 |
+|     2 |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+GROUP BY s_int
+ORDER BY 1 DESC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     2 |   3 |
+|     1 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+ORDER BY s_int ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   ORDER BY s_int ASC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY c
+ORDER BY c ASC;
++---+-----+
+| c | cnt |
++---+-----+
+|   |   3 |
+| 1 |   3 |
+| 2 |   3 |
++---+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY c
+ORDER BY 1 DESC;
++---+-----+
+| c | cnt |
++---+-----+
+| 2 |   3 |
+| 1 |   3 |
+|   |   3 |
++---+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+ORDER BY c ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   ORDER BY c ASC);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+|   |
+|   |
+|   |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   ORDER BY 1 DESC);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+|   |
+|   |
+|   |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY __time
+ORDER BY __time ASC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |   3 |
+| 2022-02-01 00:00:00.000 |   3 |
+| 2022-03-01 00:00:00.000 |   3 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY __time
+ORDER BY __time DESC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-03-01 00:00:00.000 |   3 |
+| 2022-02-01 00:00:00.000 |   3 |
+| 2022-01-01 00:00:00.000 |   3 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+ORDER BY __time ASC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+ORDER BY 1 DESC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   ORDER BY __time ASC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   ORDER BY 1 DESC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY s_int
+ORDER BY s_int ASC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|       |   3 |
+|     1 |   3 |
+|     2 |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+GROUP BY s_int
+ORDER BY 1 DESC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     2 |   3 |
+|     1 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+ORDER BY s_int ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   ORDER BY s_int ASC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY c
+ORDER BY c ASC;
++-----+-----+
+| c   | cnt |
++-----+-----+
+|     |   3 |
+| 0.1 |   3 |
+| 0.2 |   3 |
++-----+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY c
+ORDER BY 1 DESC;
++-----+-----+
+| c   | cnt |
++-----+-----+
+| 0.2 |   3 |
+| 0.1 |   3 |
+|     |   3 |
++-----+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+ORDER BY c ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   ORDER BY c ASC);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   ORDER BY 1 DESC);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY __time
+ORDER BY __time ASC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |   3 |
+| 2022-02-01 00:00:00.000 |   3 |
+| 2022-03-01 00:00:00.000 |   3 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY __time
+ORDER BY __time DESC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-03-01 00:00:00.000 |   3 |
+| 2022-02-01 00:00:00.000 |   3 |
+| 2022-01-01 00:00:00.000 |   3 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+ORDER BY __time ASC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+ORDER BY 1 DESC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   ORDER BY __time ASC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   ORDER BY 1 DESC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY s_int
+ORDER BY s_int ASC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|       |   3 |
+|     1 |   3 |
+|     2 |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+GROUP BY s_int
+ORDER BY 1 DESC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     2 |   3 |
+|     1 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+ORDER BY s_int ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   ORDER BY s_int ASC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY c
+ORDER BY c ASC;
++-----+-----+
+| c   | cnt |
++-----+-----+
+|     |   3 |
+| 0.1 |   3 |
+| 0.2 |   3 |
++-----+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY c
+ORDER BY 1 DESC;
++-----+-----+
+| c   | cnt |
++-----+-----+
+| 0.2 |   3 |
+| 0.1 |   3 |
+|     |   3 |
++-----+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+ORDER BY c ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+   ORDER BY c ASC);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+   ORDER BY 1 DESC);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY __time
+ORDER BY __time ASC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |   3 |
+| 2022-02-01 00:00:00.000 |   3 |
+| 2022-03-01 00:00:00.000 |   3 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY __time
+ORDER BY __time DESC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-03-01 00:00:00.000 |   3 |
+| 2022-02-01 00:00:00.000 |   3 |
+| 2022-01-01 00:00:00.000 |   3 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+ORDER BY __time ASC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+ORDER BY 1 DESC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+   ORDER BY __time ASC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+   ORDER BY 1 DESC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY s_int
+ORDER BY s_int ASC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|       |   3 |
+|     1 |   3 |
+|     2 |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+GROUP BY s_int
+ORDER BY 1 DESC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     2 |   3 |
+|     1 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+ORDER BY s_int ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+   ORDER BY s_int ASC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY c
+ORDER BY c ASC;
++----+-----+
+| c  | cnt |
++----+-----+
+|    |   3 |
+| S1 |   3 |
+| S2 |   3 |
++----+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY c
+ORDER BY 1 DESC;
++----+-----+
+| c  | cnt |
++----+-----+
+| S2 |   3 |
+| S1 |   3 |
+|    |   3 |
++----+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+ORDER BY c ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   ORDER BY c ASC);
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+| S2 |
+|    |
+|    |
+|    |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   ORDER BY 1 DESC);
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+| S2 |
+|    |
+|    |
+|    |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY __time
+ORDER BY __time ASC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |   3 |
+| 2022-02-01 00:00:00.000 |   3 |
+| 2022-03-01 00:00:00.000 |   3 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY __time
+ORDER BY __time DESC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-03-01 00:00:00.000 |   3 |
+| 2022-02-01 00:00:00.000 |   3 |
+| 2022-01-01 00:00:00.000 |   3 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+ORDER BY __time ASC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+ORDER BY 1 DESC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   ORDER BY __time ASC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   ORDER BY 1 DESC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY s_int
+ORDER BY s_int ASC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|       |   3 |
+|     1 |   3 |
+|     2 |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+GROUP BY s_int
+ORDER BY 1 DESC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     2 |   3 |
+|     1 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+ORDER BY s_int ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   ORDER BY s_int ASC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY c
+ORDER BY c ASC;
++----+-----+
+| c  | cnt |
++----+-----+
+|    |   3 |
+| S1 |   3 |
+| S2 |   3 |
++----+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY c
+ORDER BY 1 DESC;
++----+-----+
+| c  | cnt |
++----+-----+
+| S2 |   3 |
+| S1 |   3 |
+|    |   3 |
++----+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+ORDER BY c ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+   ORDER BY c ASC);
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+| S2 |
+|    |
+|    |
+|    |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+   ORDER BY 1 DESC);
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+| S2 |
+|    |
+|    |
+|    |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY __time
+ORDER BY __time ASC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |   3 |
+| 2022-02-01 00:00:00.000 |   3 |
+| 2022-03-01 00:00:00.000 |   3 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY __time
+ORDER BY __time DESC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-03-01 00:00:00.000 |   3 |
+| 2022-02-01 00:00:00.000 |   3 |
+| 2022-01-01 00:00:00.000 |   3 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+ORDER BY __time ASC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+ORDER BY 1 DESC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+   ORDER BY __time ASC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+   ORDER BY 1 DESC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int
+ORDER BY s_int ASC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|       |   3 |
+|     1 |   3 |
+|     2 |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int
+ORDER BY 1 DESC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     2 |   3 |
+|     1 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+ORDER BY s_int ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+   ORDER BY s_int ASC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY c
+ORDER BY c ASC;
++------+-----+
+| c    | cnt |
++------+-----+
+|      |   3 |
+| 0.1  |   3 |
+| 1    |   3 |
+| S1   |   3 |
+| true |   3 |
++------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY c
+ORDER BY 1 DESC;
++------+-----+
+| c    | cnt |
++------+-----+
+| true |   3 |
+| S1   |   3 |
+| 1    |   3 |
+| 0.1  |   3 |
+|      |   3 |
++------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+ORDER BY c ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   ORDER BY c ASC);
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| S1   |
+| true |
+| true |
+| true |
+|      |
+|      |
+|      |
++------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   ORDER BY 1 DESC);
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| S1   |
+| true |
+| true |
+| true |
+|      |
+|      |
+|      |
++------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY __time
+ORDER BY __time ASC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |   5 |
+| 2022-02-01 00:00:00.000 |   5 |
+| 2022-03-01 00:00:00.000 |   5 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY __time
+ORDER BY __time DESC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-03-01 00:00:00.000 |   5 |
+| 2022-02-01 00:00:00.000 |   5 |
+| 2022-01-01 00:00:00.000 |   5 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+ORDER BY __time ASC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+ORDER BY 1 DESC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   ORDER BY __time ASC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   ORDER BY 1 DESC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY s_int
+ORDER BY s_int ASC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|       |   5 |
+|     1 |   5 |
+|     2 |   5 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+GROUP BY s_int
+ORDER BY 1 DESC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     2 |   5 |
+|     1 |   5 |
+|       |   5 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+ORDER BY s_int ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   ORDER BY s_int ASC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
+|       |
+|       |
++-------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
+|       |
+|       |
++-------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY c
+ORDER BY c ASC;
++------+-----+
+| c    | cnt |
++------+-----+
+|      |   3 |
+| 0.1  |   3 |
+| 1    |   3 |
+| S1   |   3 |
+| true |   3 |
++------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY c
+ORDER BY 1 DESC;
++------+-----+
+| c    | cnt |
++------+-----+
+| true |   3 |
+| S1   |   3 |
+| 1    |   3 |
+| 0.1  |   3 |
+|      |   3 |
++------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+ORDER BY c ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+   ORDER BY c ASC);
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| S1   |
+| true |
+| true |
+| true |
+|      |
+|      |
+|      |
++------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+   ORDER BY 1 DESC);
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| S1   |
+| true |
+| true |
+| true |
+|      |
+|      |
+|      |
++------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY __time
+ORDER BY __time ASC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |   5 |
+| 2022-02-01 00:00:00.000 |   5 |
+| 2022-03-01 00:00:00.000 |   5 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY __time
+ORDER BY __time DESC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-03-01 00:00:00.000 |   5 |
+| 2022-02-01 00:00:00.000 |   5 |
+| 2022-01-01 00:00:00.000 |   5 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+ORDER BY __time ASC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+ORDER BY 1 DESC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+   ORDER BY __time ASC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+   ORDER BY 1 DESC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int
+ORDER BY s_int ASC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|       |   5 |
+|     1 |   5 |
+|     2 |   5 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int
+ORDER BY 1 DESC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     2 |   5 |
+|     1 |   5 |
+|       |   5 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+ORDER BY s_int ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+   ORDER BY s_int ASC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
+|       |
+|       |
++-------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
+|       |
+|       |
++-------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY c
+ORDER BY c ASC;
++---+-----+
+| c | cnt |
++---+-----+
+|   |   9 |
++---+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY c
+ORDER BY 1 DESC;
++---+-----+
+| c | cnt |
++---+-----+
+|   |   9 |
++---+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+ORDER BY c ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+   ORDER BY c ASC);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+   ORDER BY 1 DESC);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY __time
+ORDER BY __time ASC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |   3 |
+| 2022-02-01 00:00:00.000 |   3 |
+| 2022-03-01 00:00:00.000 |   3 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY __time
+ORDER BY __time DESC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-03-01 00:00:00.000 |   3 |
+| 2022-02-01 00:00:00.000 |   3 |
+| 2022-01-01 00:00:00.000 |   3 |
++-------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+ORDER BY __time ASC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+ORDER BY 1 DESC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+   ORDER BY __time ASC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+   ORDER BY 1 DESC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
+| 2022-03-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int
+ORDER BY s_int ASC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|       |   3 |
+|     1 |   3 |
+|     2 |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int
+ORDER BY 1 DESC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
+|     2 |   3 |
+|     1 |   3 |
+|       |   3 |
++-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+ORDER BY s_int ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+   ORDER BY s_int ASC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| s_int |
++-------+
+|     1 |
+|     1 |
+|     1 |
+|     2 |
+|     2 |
+|     2 |
+|       |
+|       |
+|       |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY c
+ORDER BY c ASC;
++---+-----+
+| c | cnt |
++---+-----+
++---+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY c
+ORDER BY 1 DESC;
++---+-----+
+| c | cnt |
++---+-----+
++---+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+ORDER BY c ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+   ORDER BY c ASC);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+   ORDER BY 1 DESC);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY __time
+ORDER BY __time ASC;
++--------+-----+
+| __time | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY __time
+ORDER BY __time DESC;
++--------+-----+
+| __time | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+ORDER BY __time ASC;
++--------+
+| __time |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+ORDER BY 1 DESC;
++--------+
+| __time |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+   ORDER BY __time ASC);
++--------+
+| __time |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+   ORDER BY 1 DESC);
++--------+
+| __time |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int
+ORDER BY s_int ASC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       count(*) cnt
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+GROUP BY s_int
+ORDER BY 1 DESC;
++-------+-----+
+| s_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+ORDER BY s_int ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+   ORDER BY s_int ASC);
++-------+
+| s_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int
+FROM
+  (SELECT s_int
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| s_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A1_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   LIMIT 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A1_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   8 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A1_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   LIMIT 1
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A2_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   LIMIT 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A2_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   8 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A2_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   LIMIT 1
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A3_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   LIMIT 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A3_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   8 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A3_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   LIMIT 1
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A4_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   LIMIT 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A4_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   8 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A4_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   LIMIT 1
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A5_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   LIMIT 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A5_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|  14 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A5_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   LIMIT 1
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A6_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+   LIMIT 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A6_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   8 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A6_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+   LIMIT 1
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A7_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   LIMIT 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A7_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   8 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A7_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   LIMIT 1
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A8_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+   LIMIT 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A8_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   8 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A8_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+   LIMIT 1
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A9_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+   LIMIT 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A9_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   8 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A9_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+   LIMIT 1
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A10_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+   LIMIT 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A10_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   8 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A10_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+   LIMIT 1
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A11_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+   LIMIT 1);
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A11_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A11_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+   LIMIT 1
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A12_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+   LIMIT 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A12_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|  14 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A12_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+   LIMIT 1
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(a_int) AS u(c)
+INNER JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(a_int) AS u(c)
+INNER JOIN test_unnest t2 ON u.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+INNER JOIN test_unnest t2,
+           unnest(t2.a_int) AS u(c) ON t2.s_int=u.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+INNER JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+INNER JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+INNER JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+INNER JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+INNER JOIN t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+INNER JOIN t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C12 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+INNER JOIN test_unnest t2,
+           unnest(a_int) AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C13 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+INNER JOIN test_unnest t2,
+           unnest(a_int) AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C14 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+INNER JOIN test_unnest t2,
+           unnest(a_int) AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+INNER JOIN test_unnest t2,
+           unnest(a_int) AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+INNER JOIN test_unnest,
+           unnest(a_int) t2 AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C17 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+INNER JOIN test_unnest,
+           unnest(a_int) t2 AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C18 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+INNER JOIN test_unnest,
+           unnest(a_int) t2 AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C19 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+INNER JOIN test_unnest,
+           unnest(a_int) t2 AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+INNER JOIN t1 t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+INNER JOIN t1 t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+INNER JOIN t1 t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+INNER JOIN t1 t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+INNER JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+INNER JOIN test_unnest t2 ON u.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+INNER JOIN test_unnest t2,
+           unnest(t2.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t2.s_int=u.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+INNER JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+INNER JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+INNER JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+INNER JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+INNER JOIN t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+INNER JOIN t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C12 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+INNER JOIN test_unnest t2,
+           unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C13 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+INNER JOIN test_unnest t2,
+           unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C14 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+INNER JOIN test_unnest t2,
+           unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+INNER JOIN test_unnest t2,
+           unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+INNER JOIN test_unnest,
+           unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C17 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+INNER JOIN test_unnest,
+           unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C18 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+INNER JOIN test_unnest,
+           unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C19 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+INNER JOIN test_unnest,
+           unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+INNER JOIN t1 t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+INNER JOIN t1 t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+INNER JOIN t1 t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+INNER JOIN t1 t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(a_int) AS u(c)
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN test_unnest t2,
+           unnest(t2.a_int) AS u(c)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c1
+FROM test_unnest t1
+CROSS JOIN unnest(t1.a_int) AS u1(c1)
+CROSS JOIN test_unnest t2
+CROSS JOIN unnest(t2.a_int) AS u2(c2)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+----+
+| s_int | c1 |
++-------+----+
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |    |
+|     2 |    |
+|     2 |    |
+|     2 |    |
+|     2 |    |
+|     2 |    |
++-------+----+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN t1 t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN test_unnest t2,
+           unnest(t2.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c1
+FROM test_unnest t1
+CROSS JOIN unnest(t1.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u1(c1)
+CROSS JOIN test_unnest t2
+CROSS JOIN unnest(t2.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u2(c2)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN t1 t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(a_int) AS u(c)
+JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(a_int) AS u(c)
+JOIN test_unnest t2 ON u.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+JOIN test_unnest t2,
+     unnest(t2.a_int) AS u(c) ON t2.s_int=u.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+JOIN t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+JOIN t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C12 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+JOIN test_unnest t2,
+     unnest(a_int) AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C13 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+JOIN test_unnest t2,
+     unnest(a_int) AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C14 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+JOIN test_unnest t2,
+     unnest(a_int) AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+JOIN test_unnest t2,
+     unnest(a_int) AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+JOIN test_unnest,
+     unnest(a_int) t2 AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C17 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+JOIN test_unnest,
+     unnest(a_int) t2 AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C18 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+JOIN test_unnest,
+     unnest(a_int) t2 AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C19 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+JOIN test_unnest,
+     unnest(a_int) t2 AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+JOIN t1 t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+JOIN t1 t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+JOIN t1 t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+JOIN t1 t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+JOIN test_unnest t2 ON u.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+JOIN test_unnest t2,
+     unnest(t2.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t2.s_int=u.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+JOIN t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+JOIN t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C12 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+JOIN test_unnest t2,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C13 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+JOIN test_unnest t2,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C14 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+JOIN test_unnest t2,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+JOIN test_unnest t2,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+JOIN test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C17 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+JOIN test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C18 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+JOIN test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C19 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+JOIN test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+JOIN t1 t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+JOIN t1 t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+JOIN t1 t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+JOIN t1 t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(a_int) AS u(c)
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN test_unnest t2,
+           unnest(t2.a_int) AS u(c)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c1
+FROM test_unnest t1
+CROSS JOIN unnest(t1.a_int) AS u1(c1)
+CROSS JOIN test_unnest t2
+CROSS JOIN unnest(t2.a_int) AS u2(c2)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+----+
+| s_int | c1 |
++-------+----+
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |    |
+|     2 |    |
+|     2 |    |
+|     2 |    |
+|     2 |    |
+|     2 |    |
++-------+----+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN t1 t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN test_unnest t2,
+           unnest(t2.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c1
+FROM test_unnest t1
+CROSS JOIN unnest(t1.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u1(c1)
+CROSS JOIN test_unnest t2
+CROSS JOIN unnest(t2.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u2(c2)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN t1 t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(a_int) AS u(c)
+LEFT JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(a_int) AS u(c)
+LEFT JOIN test_unnest t2 ON u.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+LEFT JOIN test_unnest t2,
+          unnest(t2.a_int) AS u(c) ON t2.s_int=u.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+LEFT JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+LEFT JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+LEFT JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+LEFT JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+LEFT JOIN t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+LEFT JOIN t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C12 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+LEFT JOIN test_unnest t2,
+          unnest(a_int) AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C13 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+LEFT JOIN test_unnest t2,
+          unnest(a_int) AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C14 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+LEFT JOIN test_unnest t2,
+          unnest(a_int) AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+LEFT JOIN test_unnest t2,
+          unnest(a_int) AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+LEFT JOIN test_unnest,
+          unnest(a_int) t2 AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C17 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+LEFT JOIN test_unnest,
+          unnest(a_int) t2 AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C18 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+LEFT JOIN test_unnest,
+          unnest(a_int) t2 AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C19 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+LEFT JOIN test_unnest,
+          unnest(a_int) t2 AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+LEFT JOIN t1 t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+LEFT JOIN t1 t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+LEFT JOIN t1 t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+LEFT JOIN t1 t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+LEFT JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+LEFT JOIN test_unnest t2 ON u.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+LEFT JOIN test_unnest t2,
+          unnest(t2.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t2.s_int=u.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+LEFT JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+LEFT JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+LEFT JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+LEFT JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+LEFT JOIN t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+LEFT JOIN t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C12 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+LEFT JOIN test_unnest t2,
+          unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C13 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+LEFT JOIN test_unnest t2,
+          unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C14 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+LEFT JOIN test_unnest t2,
+          unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+LEFT JOIN test_unnest t2,
+          unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+LEFT JOIN test_unnest,
+          unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C17 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+LEFT JOIN test_unnest,
+          unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C18 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+LEFT JOIN test_unnest,
+          unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C19 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+LEFT JOIN test_unnest,
+          unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+LEFT JOIN t1 t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+LEFT JOIN t1 t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+LEFT JOIN t1 t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+LEFT JOIN t1 t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(a_int) AS u(c)
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN test_unnest t2,
+           unnest(t2.a_int) AS u(c)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c1
+FROM test_unnest t1
+CROSS JOIN unnest(t1.a_int) AS u1(c1)
+CROSS JOIN test_unnest t2
+CROSS JOIN unnest(t2.a_int) AS u2(c2)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+----+
+| s_int | c1 |
++-------+----+
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |    |
+|     2 |    |
+|     2 |    |
+|     2 |    |
+|     2 |    |
+|     2 |    |
++-------+----+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN t1 t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN test_unnest t2,
+           unnest(t2.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c1
+FROM test_unnest t1
+CROSS JOIN unnest(t1.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u1(c1)
+CROSS JOIN test_unnest t2
+CROSS JOIN unnest(t2.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u2(c2)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN t1 t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(a_int) AS u(c)
+RIGHT JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(a_int) AS u(c)
+RIGHT JOIN test_unnest t2 ON u.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+RIGHT JOIN test_unnest t2,
+           unnest(t2.a_int) AS u(c) ON t2.s_int=u.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+RIGHT JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+RIGHT JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+RIGHT JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+RIGHT JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+RIGHT JOIN t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+RIGHT JOIN t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C12 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+RIGHT JOIN test_unnest t2,
+           unnest(a_int) AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C13 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+RIGHT JOIN test_unnest t2,
+           unnest(a_int) AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C14 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+RIGHT JOIN test_unnest t2,
+           unnest(a_int) AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+RIGHT JOIN test_unnest t2,
+           unnest(a_int) AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+RIGHT JOIN test_unnest,
+           unnest(a_int) t2 AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C17 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+RIGHT JOIN test_unnest,
+           unnest(a_int) t2 AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C18 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+RIGHT JOIN test_unnest,
+           unnest(a_int) t2 AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C19 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+RIGHT JOIN test_unnest,
+           unnest(a_int) t2 AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+RIGHT JOIN t1 t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+RIGHT JOIN t1 t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+RIGHT JOIN t1 t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+RIGHT JOIN t1 t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+RIGHT JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+RIGHT JOIN test_unnest t2 ON u.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+RIGHT JOIN test_unnest t2,
+           unnest(t2.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t2.s_int=u.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+RIGHT JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+RIGHT JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+RIGHT JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+RIGHT JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+RIGHT JOIN t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+RIGHT JOIN t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C12 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+RIGHT JOIN test_unnest t2,
+           unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C13 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+RIGHT JOIN test_unnest t2,
+           unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C14 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+RIGHT JOIN test_unnest t2,
+           unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+RIGHT JOIN test_unnest t2,
+           unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+RIGHT JOIN test_unnest,
+           unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C17 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+RIGHT JOIN test_unnest,
+           unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C18 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+RIGHT JOIN test_unnest,
+           unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C19 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+RIGHT JOIN test_unnest,
+           unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+RIGHT JOIN t1 t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+RIGHT JOIN t1 t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+RIGHT JOIN t1 t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+RIGHT JOIN t1 t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(a_int) AS u(c)
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN test_unnest t2,
+           unnest(t2.a_int) AS u(c)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c1
+FROM test_unnest t1
+CROSS JOIN unnest(t1.a_int) AS u1(c1)
+CROSS JOIN test_unnest t2
+CROSS JOIN unnest(t2.a_int) AS u2(c2)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+----+
+| s_int | c1 |
++-------+----+
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |    |
+|     2 |    |
+|     2 |    |
+|     2 |    |
+|     2 |    |
+|     2 |    |
++-------+----+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN t1 t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN test_unnest t2,
+           unnest(t2.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c1
+FROM test_unnest t1
+CROSS JOIN unnest(t1.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u1(c1)
+CROSS JOIN test_unnest t2
+CROSS JOIN unnest(t2.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u2(c2)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN t1 t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(a_int) AS u(c)
+FULL JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(a_int) AS u(c)
+FULL JOIN test_unnest t2 ON u.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+FULL JOIN test_unnest t2,
+          unnest(t2.a_int) AS u(c) ON t2.s_int=u.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+FULL JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+FULL JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+FULL JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+FULL JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+FULL JOIN t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+FULL JOIN t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C12 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+FULL JOIN test_unnest t2,
+          unnest(a_int) AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C13 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+FULL JOIN test_unnest t2,
+          unnest(a_int) AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C14 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+FULL JOIN test_unnest t2,
+          unnest(a_int) AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+FULL JOIN test_unnest t2,
+          unnest(a_int) AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+FULL JOIN test_unnest,
+          unnest(a_int) t2 AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C17 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+FULL JOIN test_unnest,
+          unnest(a_int) t2 AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C18 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+FULL JOIN test_unnest,
+          unnest(a_int) t2 AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C19 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(a_int) AS u(c)
+FULL JOIN test_unnest,
+          unnest(a_int) t2 AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+FULL JOIN t1 t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+FULL JOIN t1 t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+FULL JOIN t1 t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+FULL JOIN t1 t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+FULL JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+FULL JOIN test_unnest t2 ON u.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+FULL JOIN test_unnest t2,
+          unnest(t2.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t2.s_int=u.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+FULL JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+FULL JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+FULL JOIN test_unnest t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+FULL JOIN test_unnest t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+FULL JOIN t2 ON t2.s_int=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+FULL JOIN t2 ON t2.c=t1.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C12 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+FULL JOIN test_unnest t2,
+          unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C13 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+FULL JOIN test_unnest t2,
+          unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C14 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+FULL JOIN test_unnest t2,
+          unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+FULL JOIN test_unnest t2,
+          unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+FULL JOIN test_unnest,
+          unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C17 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+FULL JOIN test_unnest,
+          unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C18 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+FULL JOIN test_unnest,
+          unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C19 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+FULL JOIN test_unnest,
+          unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u(c) ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+FULL JOIN t1 t2 ON t1.s_int=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+FULL JOIN t1 t2 ON t1.c=t2.s_int
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+FULL JOIN t1 t2 ON t1.s_int=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+FULL JOIN t1 t2 ON t1.c=t2.c
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
++-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(a_int) AS u(c)
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN test_unnest t2,
+           unnest(t2.a_int) AS u(c)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c1
+FROM test_unnest t1
+CROSS JOIN unnest(t1.a_int) AS u1(c1)
+CROSS JOIN test_unnest t2
+CROSS JOIN unnest(t2.a_int) AS u2(c2)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+----+
+| s_int | c1 |
++-------+----+
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  1 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |  2 |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     1 |    |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  1 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |  2 |
+|     2 |    |
+|     2 |    |
+|     2 |    |
+|     2 |    |
+|     2 |    |
+|     2 |    |
++-------+----+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN t1 t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN test_unnest t2,
+           unnest(t2.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
++-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       c1
+FROM test_unnest t1
+CROSS JOIN unnest(t1.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u1(c1)
+CROSS JOIN test_unnest t2
+CROSS JOIN unnest(t2.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u2(c2)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN t1 t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999);
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 1 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 | 2 |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 1 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 | 2 |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t2.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(a_int) AS u(c),
+           test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
++-------+-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       c
+FROM (test_unnest t1
+      CROSS JOIN unnest(a_int) AS u(c))
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND u.c=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
++-------+-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int=t1.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
++-------+-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.c=t1.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       c
+FROM t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
++-------+-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       c
+FROM t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int=t1.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
++-------+-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.c=t1.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       c1
+FROM test_unnest t1,
+     unnest(t1.a_int) AS u1(c1)
+CROSS JOIN test_unnest,
+           unnest(t2.a_int) t2 AS u2(c2)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.s_int;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C17 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       c1
+FROM test_unnest t1,
+     unnest(t1.a_int) AS u1(c1)
+CROSS JOIN test_unnest,
+           unnest(t2.a_int) t2 AS u2(c2)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c1=t2.s_int;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C18 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       c1
+FROM test_unnest t1,
+     unnest(t1.a_int) AS u1(c1)
+CROSS JOIN test_unnest,
+           unnest(t2.a_int) t2 AS u2(c2)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.c2;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C19 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       c1
+FROM test_unnest t1,
+     unnest(t1.a_int) AS u1(c1)
+CROSS JOIN test_unnest,
+           unnest(t2.a_int) t2 AS u2(c2)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c1=t2.c2;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     1 |     1 |   |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
+|     2 |     2 |   |
+|     2 |     2 |   |
++-------+-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.c;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
+|     2 |     2 |   |
++-------+-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c=t2.c;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     1 |     1 |   |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
+|     2 |     2 |   |
+|     2 |     2 |   |
++-------+-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.c;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
+|     2 |     2 |   |
++-------+-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c=t2.c;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN t1 t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     1 |     1 |   |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
+|     2 |     2 |   |
+|     2 |     2 |   |
++-------+-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN t1 t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN t1 t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.c;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
+|     2 |     2 |   |
++-------+-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN t1 t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c=t2.c;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t2.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c),
+           test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
++-------+-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       c
+FROM (test_unnest t1
+      CROSS JOIN unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND u.c=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
++-------+-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int=t1.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
++-------+-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.c=t1.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       c
+FROM t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
++-------+-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       c
+FROM t1
+CROSS JOIN test_unnest t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int=t1.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
++-------+-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       c
+FROM test_unnest t1
+CROSS JOIN t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.c=t1.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       c1
+FROM test_unnest t1,
+     unnest(t1.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u1(c1)
+CROSS JOIN test_unnest,
+           unnest(t2.json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u2(c2)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.s_int;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C17 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       c1
+FROM test_unnest t1,
+     unnest(t1.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u1(c1)
+CROSS JOIN test_unnest,
+           unnest(t2.json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u2(c2)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c1=t2.s_int;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C18 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       c1
+FROM test_unnest t1,
+     unnest(t1.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u1(c1)
+CROSS JOIN test_unnest,
+           unnest(t2.json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u2(c2)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.c2;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C19 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       c1
+FROM test_unnest t1,
+     unnest(t1.json_value(a_nested, '$[1]' RETURNING bigint array)) AS u1(c1)
+CROSS JOIN test_unnest,
+           unnest(t2.json_value(a_nested, '$[1]' RETURNING bigint array)) t2 AS u2(c2)
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c1=t2.c2;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     1 |     1 |   |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
+|     2 |     2 |   |
+|     2 |     2 |   |
++-------+-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.c;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
+|     2 |     2 |   |
++-------+-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c=t2.c;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     1 |     1 |   |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
+|     2 |     2 |   |
+|     2 |     2 |   |
++-------+-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.c;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
+|     2 |     2 |   |
++-------+-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)) t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c=t2.c;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN t1 t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     1 |     1 |   |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
+|     2 |     2 |   |
+|     2 |     2 |   |
++-------+-------+---+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN t1 t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c=t2.s_int;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN t1 t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.s_int=t2.c;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     1 |     1 |   |
+|     1 |     1 |   |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
+|     2 |     2 |   |
+|     2 |     2 |   |
++-------+-------+---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c))
+SELECT t1.s_int,
+       t1.s_int,
+       t1.c
+FROM t1
+CROSS JOIN t1 t2
+WHERE t1.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t2.s_int IN (0,
+                   1,
+                   2,
+                   999)
+  AND t1.c=t2.c;
++-------+-------+---+
+| s_int | s_int | c |
++-------+-------+---+
+|     1 |     1 | 1 |
+|     1 |     1 | 1 |
+|     1 |     1 | 2 |
+|     1 |     1 | 2 |
+|     2 |     2 | 1 |
+|     2 |     2 | 1 |
+|     2 |     2 | 2 |
+|     2 |     2 | 2 |
++-------+-------+---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   999)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int IN (2,
+                   999));
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 0 |
+|     1 | 1 |
+|     1 |   |
+|     2 | 0 |
+|     2 | 1 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A1_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A2_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   999)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+   WHERE s_int IN (2,
+                   999));
++-------+-------+
+| s_int | c     |
++-------+-------+
+|     1 | false |
+|     1 | true  |
+|     1 |       |
+|     2 | false |
+|     2 | true  |
+|     2 |       |
++-------+-------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A2_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS u(c));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A3_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   999)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (2,
+                   999));
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A3_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   999)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (2,
+                   999));
++-------+---+
+| s_int | c |
++-------+---+
+|     1 | 1 |
+|     1 | 2 |
+|     1 |   |
+|     2 | 1 |
+|     2 | 2 |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A4_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   999)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int IN (2,
+                   999));
++-------+-----+
+| s_int | c   |
++-------+-----+
+|     1 | 0.1 |
+|     1 | 0.2 |
+|     1 |     |
+|     2 | 0.1 |
+|     2 | 0.2 |
+|     2 |     |
++-------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A5_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   999)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+   WHERE s_int IN (2,
+                   999));
++-------+-----+
+| s_int | c   |
++-------+-----+
+|     1 | 0.1 |
+|     1 | 0.2 |
+|     1 |     |
+|     2 | 0.1 |
+|     2 | 0.2 |
+|     2 |     |
++-------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A6_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[2]' RETURNING DOUBLE array)) AS u(c));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   999)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int IN (2,
+                   999));
++-------+----+
+| s_int | c  |
++-------+----+
+|     1 | S1 |
+|     1 | S2 |
+|     1 |    |
+|     2 | S1 |
+|     2 | S2 |
+|     2 |    |
++-------+----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A7_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A8_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   999)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+   WHERE s_int IN (2,
+                   999));
++-------+----+
+| s_int | c  |
++-------+----+
+|     1 | S1 |
+|     1 | S2 |
+|     1 |    |
+|     2 | S1 |
+|     2 | S2 |
+|     2 |    |
++-------+----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A8_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS u(c));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A9_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   999)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int IN (2,
+                   999));
++-------+------+
+| s_int | c    |
++-------+------+
+|     1 | 0.1  |
+|     1 | 1    |
+|     1 | S1   |
+|     1 | true |
+|     1 |      |
+|     2 | 0.1  |
+|     2 | 1    |
+|     2 | S1   |
+|     2 | true |
+|     2 |      |
++-------+------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A9_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A10_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   999)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+   WHERE s_int IN (2,
+                   999));
++-------+------+
+| s_int | c    |
++-------+------+
+|     1 | 0.1  |
+|     1 | 1    |
+|     1 | S1   |
+|     1 | true |
+|     1 |      |
+|     2 | 0.1  |
+|     2 | 1    |
+|     2 | S1   |
+|     2 | true |
+|     2 |      |
++-------+------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A10_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS u(c));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A11_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   999)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+   WHERE s_int IN (2,
+                   999));
++-------+---+
+| s_int | c |
++-------+---+
+|     1 |   |
+|     1 |   |
+|     1 |   |
+|     2 |   |
+|     2 |   |
+|     2 |   |
++-------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A11_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS u(c));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A12_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   999)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+   WHERE s_int IN (2,
+                   999));
++-------+---+
+| s_int | c |
++-------+---+
++-------+---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A12_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS u(c));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# Total query count 1091 Positive tests: 907 Negative tests: 184
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql_filter.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql_filter.iq
new file mode 100644
index 000000000000..d53f24183749
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql_filter.iq
@@ -0,0 +1,24180 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaUnnest/array&numMergeBuffers=3
+!set outputformat mysql
+SELECT *
+FROM test_unnest;
++-------------------------+-------+--------+--------------+--------------+------------------+----------------+--------------------+---------+--------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| __time                  | s_int | s_null | a_bool       | a_int        | a_float          | a_str          | a_null             | a_empty | a_mixed                  | a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------+-------+--------+--------------+--------------+------------------+----------------+--------------------+---------+--------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| 2022-01-01 00:00:00.000 |     1 |        | [1, 0, null] | [1, 2, null] | [0.1, 0.2, null] | [S1, S2, null] | [null, null, null] | []      | [true, 1, 0.1, S1, null] | [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| 2022-02-01 00:00:00.000 |     2 |        | [null, 1, 0] | [null, 1, 2] | [null, 0.1, 0.2] | [null, S1, S2] | [null, null, null] | []      | [null, true, 1, 0.1, S1] | [[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"],[[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"],[[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"]]]] |
+| 2022-03-01 00:00:00.000 |       |        | [0, null, 1] | [2, null, 1] | [0.2, null, 0.1] | [S2, null, S1] | [null, null, null] | []      | [S1, null, true, 1, 0.1] | [[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1],[[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1],[[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1]]]] |
++-------------------------+-------+--------+--------------+--------------+------------------+----------------+--------------------+---------+--------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE c=1;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE c=1);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c=1), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE c=1;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE c=1;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE c<>1;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE c<>1);
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<>1), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE c<>1;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE c<>1;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE c>1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE c>1);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>1), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE c>1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE c>1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE c>=1;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE c>=1);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>=1), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE c>=1;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE c>=1;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE c<1;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE c<1);
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<1), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE c<1;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE c<1;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE c<=1;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE c<=1);
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<=1), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE c<=1;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE c<=1;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE (NOT c<>1
+       OR NOT c<>998)
+  AND (NOT c=0
+       OR NOT c=999);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE (NOT c<>1
+          OR NOT c<>998)
+     AND (NOT c=0
+          OR NOT c=999));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT c<>1
+          OR NOT c<>998)
+     AND (NOT c=0
+          OR NOT c=999)), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE (NOT c<>1
+       OR NOT c<>998)
+  AND (NOT c=0
+       OR NOT c=999);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE (NOT c<>1
+       OR NOT c<>998)
+  AND (NOT c=0
+       OR NOT c=999);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE (c=1
+       OR c=998)
+  AND NOT c=0
+  AND NOT c=999;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE (c=1
+          OR c=998)
+     AND NOT c=0
+     AND NOT c=999);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c=1
+          OR c=998)
+     AND NOT c=0
+     AND NOT c=999), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE (c=1
+       OR c=998)
+  AND NOT c=0
+  AND NOT c=999;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE (c=1
+       OR c=998)
+  AND NOT c=0
+  AND NOT c=999;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE c IS NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NULL), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE c IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE c IS NOT NULL);
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NOT NULL), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE c IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE c IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE c IN (1,
+            998) IS TRUE
+  AND c IN (0,
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE c IN (1,
+               998) IS TRUE
+     AND c IN (0,
+               999) IS NOT TRUE);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN (1,
+               998) IS TRUE
+     AND c IN (0,
+               999) IS NOT TRUE), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE c IN (1,
+            998) IS TRUE
+  AND c IN (0,
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE c IN (1,
+            998) IS TRUE
+  AND c IN (0,
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE c IN (1,
+            998) IS FALSE
+  AND c IN (0,
+            999) IS NOT FALSE;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE c IN (1,
+               998) IS FALSE
+     AND c IN (0,
+               999) IS NOT FALSE);
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN (1,
+               998) IS FALSE
+     AND c IN (0,
+               999) IS NOT FALSE), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE c IN (1,
+            998) IS FALSE
+  AND c IN (0,
+            999) IS NOT FALSE;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE c IN (1,
+            998) IS FALSE
+  AND c IN (0,
+            999) IS NOT FALSE;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE (c BETWEEN 1 AND 2)
+  AND (c NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE (c BETWEEN 1 AND 2)
+     AND (c NOT BETWEEN 3 AND 4));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c BETWEEN 1 AND 2)
+     AND (c NOT BETWEEN 3 AND 4)), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE (c BETWEEN 1 AND 2)
+  AND (c NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE (c BETWEEN 1 AND 2)
+  AND (c NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE (cast(c AS varchar) like '%1%')
+  AND (cast(c AS varchar) not like '%3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE (cast(c AS varchar) like '%1%')
+     AND (cast(c AS varchar) not like '%3%'));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (cast(c AS varchar) like '%1%')
+     AND (cast(c AS varchar) not like '%3%')), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE (cast(c AS varchar) like '%1%')
+  AND (cast(c AS varchar) not like '%3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE (cast(c AS varchar) like '%1%')
+  AND (cast(c AS varchar) not like '%3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE c IN (1,
+            998)
+  AND c NOT IN (0,
+                999);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE c IN (1,
+               998)
+     AND c NOT IN (0,
+                   999));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN (1,
+               998)
+     AND c NOT IN (0,
+                   999)), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE c IN (1,
+            998)
+  AND c NOT IN (0,
+                999);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE c IN (1,
+            998)
+  AND c NOT IN (0,
+                999);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(1),(998)) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(999)) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(1),(998)) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0),(999)) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(1),(998)) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0),(999)) AS t(col))), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(1),(998)) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(999)) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(1),(998)) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(999)) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int=1
+  AND c=1;
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int=1
+     AND c=1);
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int=1
+     AND c=1), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int=1
+  AND c=1;
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int=1
+  AND c=1;
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int<>1
+  AND c<>1;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int<>1
+     AND c<>1);
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<>1
+     AND c<>1), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int<>1
+  AND c<>1;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int<>1
+  AND c<>1;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int>1
+  AND c>1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int>1
+     AND c>1);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>1
+     AND c>1), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int>1
+  AND c>1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int>1
+  AND c>1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int>=1
+  AND c>=1;
++---+
+| c |
++---+
+| 1 |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int>=1
+     AND c>=1);
++---+
+| c |
++---+
+| 1 |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>=1
+     AND c>=1), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int>=1
+  AND c>=1;
++---+
+| c |
++---+
+| 1 |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int>=1
+  AND c>=1;
++---+
+| c |
++---+
+| 1 |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int<1
+  AND c<1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int<1
+     AND c<1);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<1
+     AND c<1), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int<1
+  AND c<1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int<1
+  AND c<1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int<=1
+  AND c<=1;
++---+
+| c |
++---+
+| 0 |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int<=1
+     AND c<=1);
++---+
+| c |
++---+
+| 0 |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<=1
+     AND c<=1), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int<=1
+  AND c<=1;
++---+
+| c |
++---+
+| 0 |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int<=1
+  AND c<=1;
++---+
+| c |
++---+
+| 0 |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int=999)
+  AND (NOT c<>1
+       OR NOT c<>998)
+  AND (NOT c=0
+       OR NOT c=999);
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int=999)
+     AND (NOT c<>1
+          OR NOT c<>998)
+     AND (NOT c=0
+          OR NOT c=999));
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int=999)
+     AND (NOT c<>1
+          OR NOT c<>998)
+     AND (NOT c=0
+          OR NOT c=999)), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int=999)
+  AND (NOT c<>1
+       OR NOT c<>998)
+  AND (NOT c=0
+       OR NOT c=999);
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int=999)
+  AND (NOT c<>1
+       OR NOT c<>998)
+  AND (NOT c=0
+       OR NOT c=999);
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int=999
+  AND (c=1
+       OR c=998)
+  AND NOT c=0
+  AND NOT c=999;
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int=999
+     AND (c=1
+          OR c=998)
+     AND NOT c=0
+     AND NOT c=999);
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int=999
+     AND (c=1
+          OR c=998)
+     AND NOT c=0
+     AND NOT c=999), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int=999
+  AND (c=1
+       OR c=998)
+  AND NOT c=0
+  AND NOT c=999;
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int=999
+  AND (c=1
+       OR c=998)
+  AND NOT c=0
+  AND NOT c=999;
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int IS NULL
+     AND c IS NULL);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NULL
+     AND c IS NULL), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int IS NOT NULL
+  AND c IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 1 |
+| 1 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int IS NOT NULL
+     AND c IS NOT NULL);
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 1 |
+| 1 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NOT NULL
+     AND c IS NOT NULL), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int IS NOT NULL
+  AND c IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 1 |
+| 1 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int IS NOT NULL
+  AND c IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 1 |
+| 1 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE
+  AND c IN (1,
+            998) IS TRUE
+  AND c IN (0,
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE
+     AND c IN (1,
+               998) IS TRUE
+     AND c IN (0,
+               999) IS NOT TRUE);
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE
+     AND c IN (1,
+               998) IS TRUE
+     AND c IN (0,
+               999) IS NOT TRUE), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE
+  AND c IN (1,
+            998) IS TRUE
+  AND c IN (0,
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE
+  AND c IN (1,
+            998) IS TRUE
+  AND c IN (0,
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE
+  AND c IN (1,
+            998) IS FALSE
+  AND c IN (0,
+            999) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE
+     AND c IN (1,
+               998) IS FALSE
+     AND c IN (0,
+               999) IS NOT FALSE);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE
+     AND c IN (1,
+               998) IS FALSE
+     AND c IN (0,
+               999) IS NOT FALSE), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE
+  AND c IN (1,
+            998) IS FALSE
+  AND c IN (0,
+            999) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE
+  AND c IN (1,
+            998) IS FALSE
+  AND c IN (0,
+            999) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN 1 AND 2)
+  AND (c NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+| 1 |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN 1 AND 2)
+     AND (c NOT BETWEEN 3 AND 4));
++---+
+| c |
++---+
+| 1 |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN 1 AND 2)
+     AND (c NOT BETWEEN 3 AND 4)), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN 1 AND 2)
+  AND (c NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+| 1 |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN 1 AND 2)
+  AND (c NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+| 1 |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%')
+  AND (cast(c AS varchar) like '%1%')
+  AND (cast(c AS varchar) not like '%3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%')
+     AND (cast(c AS varchar) like '%1%')
+     AND (cast(c AS varchar) not like '%3%'));
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%')
+     AND (cast(c AS varchar) like '%1%')
+     AND (cast(c AS varchar) not like '%3%')), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%')
+  AND (cast(c AS varchar) like '%1%')
+  AND (cast(c AS varchar) not like '%3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%')
+  AND (cast(c AS varchar) like '%1%')
+  AND (cast(c AS varchar) not like '%3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997)
+  AND c IN (1,
+            998)
+  AND c NOT IN (0,
+                999);
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997)
+     AND c IN (1,
+               998)
+     AND c NOT IN (0,
+                   999));
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997)
+     AND c IN (1,
+               998)
+     AND c NOT IN (0,
+                   999)), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997)
+  AND c IN (1,
+            998)
+  AND c NOT IN (0,
+                999);
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997)
+  AND c IN (1,
+            998)
+  AND c NOT IN (0,
+                999);
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(997)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(1),(998)) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(999)) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0),(997)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(1),(998)) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0),(999)) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0),(997)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(1),(998)) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0),(999)) AS t(col))), unnest(a_bool) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(997)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(1),(998)) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(999)) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(997)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(1),(998)) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(999)) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int=1;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int=1);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int=1), unnest(a_bool) AS u(c);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int=1;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int=1;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int<>1;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int<>1);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<>1), unnest(a_bool) AS u(c);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int<>1;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int<>1;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int>1;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int>1);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>1), unnest(a_bool) AS u(c);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int>1;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int>1;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int>=1;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int>=1);
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>=1), unnest(a_bool) AS u(c);
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int>=1;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int>=1;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int<1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int<1);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<1), unnest(a_bool) AS u(c);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int<1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int<1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int<=1;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int<=1);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<=1), unnest(a_bool) AS u(c);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int<=1;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int<=1;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int=999);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int=999));
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int=999)), unnest(a_bool) AS u(c);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int=999);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int=999);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int=999;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int=999);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int=999), unnest(a_bool) AS u(c);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int=999;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int=999;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int IS NULL;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int IS NULL);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NULL), unnest(a_bool) AS u(c);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int IS NULL;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int IS NULL;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int IS NOT NULL);
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NOT NULL), unnest(a_bool) AS u(c);
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE), unnest(a_bool) AS u(c);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE;
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE), unnest(a_bool) AS u(c);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4));
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4)), unnest(a_bool) AS u(c);
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%');
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%'));
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%')), unnest(a_bool) AS u(c);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%');
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%');
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B47_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B47_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997));
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B47_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997)), unnest(a_bool) AS u(c);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B47_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B47_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B48_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_bool) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(997)) AS t(col));
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B48_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c)
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0),(997)) AS t(col)));
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B48_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0),(997)) AS t(col))), unnest(a_bool) AS u(c);
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B48_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_bool) AS u(c))
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(997)) AS t(col));
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B48_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_bool) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(997)) AS t(col));
++---+
+| c |
++---+
+| 0 |
+| 1 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE c=2;
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE c=2);
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c=2), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE c=2;
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE c=2;
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE c<>2;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE c<>2);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<>2), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE c<>2;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE c<>2;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE c>2;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE c>2);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>2), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE c>2;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE c>2;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE c>=2;
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE c>=2);
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>=2), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE c>=2;
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE c>=2;
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE c<2;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE c<2);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<2), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE c<2;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE c<2;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE c<=2;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE c<=2);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<=2), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE c<=2;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE c<=2;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (NOT c<>2
+       OR NOT c<>998)
+  AND (NOT c=1
+       OR NOT c=999);
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE (NOT c<>2
+          OR NOT c<>998)
+     AND (NOT c=1
+          OR NOT c=999));
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT c<>2
+          OR NOT c<>998)
+     AND (NOT c=1
+          OR NOT c=999)), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE (NOT c<>2
+       OR NOT c<>998)
+  AND (NOT c=1
+       OR NOT c=999);
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE (NOT c<>2
+       OR NOT c<>998)
+  AND (NOT c=1
+       OR NOT c=999);
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (c=2
+       OR c=998)
+  AND NOT c=1
+  AND NOT c=999;
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE (c=2
+          OR c=998)
+     AND NOT c=1
+     AND NOT c=999);
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c=2
+          OR c=998)
+     AND NOT c=1
+     AND NOT c=999), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE (c=2
+       OR c=998)
+  AND NOT c=1
+  AND NOT c=999;
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE (c=2
+       OR c=998)
+  AND NOT c=1
+  AND NOT c=999;
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE c IS NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NULL), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE c IS NOT NULL;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE c IS NOT NULL);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NOT NULL), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE c IS NOT NULL;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE c IS NOT NULL;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE c IN (2,
+            998) IS TRUE
+  AND c IN (1,
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE c IN (2,
+               998) IS TRUE
+     AND c IN (1,
+               999) IS NOT TRUE);
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN (2,
+               998) IS TRUE
+     AND c IN (1,
+               999) IS NOT TRUE), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE c IN (2,
+            998) IS TRUE
+  AND c IN (1,
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE c IN (2,
+            998) IS TRUE
+  AND c IN (1,
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE c IN (2,
+            998) IS FALSE
+  AND c IN (1,
+            999) IS NOT FALSE;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE c IN (2,
+               998) IS FALSE
+     AND c IN (1,
+               999) IS NOT FALSE);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN (2,
+               998) IS FALSE
+     AND c IN (1,
+               999) IS NOT FALSE), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE c IN (2,
+            998) IS FALSE
+  AND c IN (1,
+            999) IS NOT FALSE;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE c IN (2,
+            998) IS FALSE
+  AND c IN (1,
+            999) IS NOT FALSE;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (c BETWEEN 2 AND 3)
+  AND (c NOT BETWEEN 4 AND 5);
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE (c BETWEEN 2 AND 3)
+     AND (c NOT BETWEEN 4 AND 5));
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c BETWEEN 2 AND 3)
+     AND (c NOT BETWEEN 4 AND 5)), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE (c BETWEEN 2 AND 3)
+  AND (c NOT BETWEEN 4 AND 5);
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE (c BETWEEN 2 AND 3)
+  AND (c NOT BETWEEN 4 AND 5);
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (cast(c AS varchar) like '%2%')
+  AND (cast(c AS varchar) not like '%3%');
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE (cast(c AS varchar) like '%2%')
+     AND (cast(c AS varchar) not like '%3%'));
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (cast(c AS varchar) like '%2%')
+     AND (cast(c AS varchar) not like '%3%')), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE (cast(c AS varchar) like '%2%')
+  AND (cast(c AS varchar) not like '%3%');
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE (cast(c AS varchar) like '%2%')
+  AND (cast(c AS varchar) not like '%3%');
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE c IN (2,
+            998)
+  AND c NOT IN (1,
+                999);
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE c IN (2,
+               998)
+     AND c NOT IN (1,
+                   999));
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN (2,
+               998)
+     AND c NOT IN (1,
+                   999)), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE c IN (2,
+            998)
+  AND c NOT IN (1,
+                999);
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE c IN (2,
+            998)
+  AND c NOT IN (1,
+                999);
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(2),(998)) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES(1),(999)) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(2),(998)) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES(1),(999)) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(2),(998)) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES(1),(999)) AS t(col))), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(2),(998)) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES(1),(999)) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(2),(998)) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES(1),(999)) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int=1
+  AND c=2;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int=1
+     AND c=2);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int=1
+     AND c=2), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int=1
+  AND c=2;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int=1
+  AND c=2;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int<>1
+  AND c<>2;
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int<>1
+     AND c<>2);
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<>1
+     AND c<>2), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int<>1
+  AND c<>2;
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int<>1
+  AND c<>2;
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int>1
+  AND c>2;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int>1
+     AND c>2);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>1
+     AND c>2), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int>1
+  AND c>2;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int>1
+  AND c>2;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int>=1
+  AND c>=2;
++---+
+| c |
++---+
+| 2 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int>=1
+     AND c>=2);
++---+
+| c |
++---+
+| 2 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>=1
+     AND c>=2), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int>=1
+  AND c>=2;
++---+
+| c |
++---+
+| 2 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int>=1
+  AND c>=2;
++---+
+| c |
++---+
+| 2 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int<1
+  AND c<2;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int<1
+     AND c<2);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<1
+     AND c<2), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int<1
+  AND c<2;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int<1
+  AND c<2;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int<=1
+  AND c<=2;
++---+
+| c |
++---+
+| 1 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int<=1
+     AND c<=2);
++---+
+| c |
++---+
+| 1 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<=1
+     AND c<=2), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int<=1
+  AND c<=2;
++---+
+| c |
++---+
+| 1 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int<=1
+  AND c<=2;
++---+
+| c |
++---+
+| 1 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int=999)
+  AND (NOT c<>2
+       OR NOT c<>998)
+  AND (NOT c=1
+       OR NOT c=999);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int=999)
+     AND (NOT c<>2
+          OR NOT c<>998)
+     AND (NOT c=1
+          OR NOT c=999));
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int=999)
+     AND (NOT c<>2
+          OR NOT c<>998)
+     AND (NOT c=1
+          OR NOT c=999)), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int=999)
+  AND (NOT c<>2
+       OR NOT c<>998)
+  AND (NOT c=1
+       OR NOT c=999);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int=999)
+  AND (NOT c<>2
+       OR NOT c<>998)
+  AND (NOT c=1
+       OR NOT c=999);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int=999
+  AND (c=2
+       OR c=998)
+  AND NOT c=1
+  AND NOT c=999;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int=999
+     AND (c=2
+          OR c=998)
+     AND NOT c=1
+     AND NOT c=999);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int=999
+     AND (c=2
+          OR c=998)
+     AND NOT c=1
+     AND NOT c=999), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int=999
+  AND (c=2
+       OR c=998)
+  AND NOT c=1
+  AND NOT c=999;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int=999
+  AND (c=2
+       OR c=998)
+  AND NOT c=1
+  AND NOT c=999;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IS NULL
+     AND c IS NULL);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NULL
+     AND c IS NULL), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IS NOT NULL
+  AND c IS NOT NULL;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IS NOT NULL
+     AND c IS NOT NULL);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NOT NULL
+     AND c IS NOT NULL), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int IS NOT NULL
+  AND c IS NOT NULL;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int IS NOT NULL
+  AND c IS NOT NULL;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE
+  AND c IN (2,
+            998) IS TRUE
+  AND c IN (1,
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE
+     AND c IN (2,
+               998) IS TRUE
+     AND c IN (1,
+               999) IS NOT TRUE);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE
+     AND c IN (2,
+               998) IS TRUE
+     AND c IN (1,
+               999) IS NOT TRUE), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE
+  AND c IN (2,
+            998) IS TRUE
+  AND c IN (1,
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE
+  AND c IN (2,
+            998) IS TRUE
+  AND c IN (1,
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE
+  AND c IN (2,
+            998) IS FALSE
+  AND c IN (1,
+            999) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE
+     AND c IN (2,
+               998) IS FALSE
+     AND c IN (1,
+               999) IS NOT FALSE);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE
+     AND c IN (2,
+               998) IS FALSE
+     AND c IN (1,
+               999) IS NOT FALSE), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE
+  AND c IN (2,
+            998) IS FALSE
+  AND c IN (1,
+            999) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE
+  AND c IN (2,
+            998) IS FALSE
+  AND c IN (1,
+            999) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN 2 AND 3)
+  AND (c NOT BETWEEN 4 AND 5);
++---+
+| c |
++---+
+| 2 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN 2 AND 3)
+     AND (c NOT BETWEEN 4 AND 5));
++---+
+| c |
++---+
+| 2 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN 2 AND 3)
+     AND (c NOT BETWEEN 4 AND 5)), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN 2 AND 3)
+  AND (c NOT BETWEEN 4 AND 5);
++---+
+| c |
++---+
+| 2 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN 2 AND 3)
+  AND (c NOT BETWEEN 4 AND 5);
++---+
+| c |
++---+
+| 2 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%')
+  AND (cast(c AS varchar) like '%2%')
+  AND (cast(c AS varchar) not like '%3%');
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%')
+     AND (cast(c AS varchar) like '%2%')
+     AND (cast(c AS varchar) not like '%3%'));
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%')
+     AND (cast(c AS varchar) like '%2%')
+     AND (cast(c AS varchar) not like '%3%')), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%')
+  AND (cast(c AS varchar) like '%2%')
+  AND (cast(c AS varchar) not like '%3%');
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%')
+  AND (cast(c AS varchar) like '%2%')
+  AND (cast(c AS varchar) not like '%3%');
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997)
+  AND c IN (2,
+            998)
+  AND c NOT IN (1,
+                999);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997)
+     AND c IN (2,
+               998)
+     AND c NOT IN (1,
+                   999));
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997)
+     AND c IN (2,
+               998)
+     AND c NOT IN (1,
+                   999)), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997)
+  AND c IN (2,
+            998)
+  AND c NOT IN (1,
+                999);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997)
+  AND c IN (2,
+            998)
+  AND c NOT IN (1,
+                999);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(1),(997)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(2),(998)) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES(1),(999)) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(1),(997)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(2),(998)) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES(1),(999)) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(1),(997)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(2),(998)) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES(1),(999)) AS t(col))), unnest(a_int) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(1),(997)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(2),(998)) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES(1),(999)) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(1),(997)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(2),(998)) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES(1),(999)) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int=1;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int=1);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int=1), unnest(a_int) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int=1;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int=1;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int<>1;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int<>1);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<>1), unnest(a_int) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int<>1;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int<>1;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int>1;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int>1);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>1), unnest(a_int) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int>1;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int>1;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int>=1;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int>=1);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>=1), unnest(a_int) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int>=1;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int>=1;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int<1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int<1);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<1), unnest(a_int) AS u(c);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int<1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int<1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int<=1;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int<=1);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<=1), unnest(a_int) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int<=1;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int<=1;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int=999);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int=999));
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int=999)), unnest(a_int) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int=999);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int=999);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int=999;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int=999);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int=999), unnest(a_int) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int=999;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int=999;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IS NULL;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IS NULL);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NULL), unnest(a_int) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int IS NULL;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int IS NULL;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IS NOT NULL;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IS NOT NULL);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NOT NULL), unnest(a_int) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int IS NOT NULL;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int IS NOT NULL;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE), unnest(a_int) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE;
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE), unnest(a_int) AS u(c);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4)), unnest(a_int) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%');
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%'));
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%')), unnest(a_int) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%');
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%');
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B47_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B47_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997));
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B47_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997)), unnest(a_int) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B47_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B47_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B48_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(997)) AS t(col));
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B48_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0),(997)) AS t(col)));
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B48_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0),(997)) AS t(col))), unnest(a_int) AS u(c);
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B48_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_int) AS u(c))
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(997)) AS t(col));
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B48_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_int) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(997)) AS t(col));
++---+
+| c |
++---+
+| 1 |
+| 2 |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE c=0.2;
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE c=0.2);
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c=0.2), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE c=0.2;
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE c=0.2;
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE c<>0.2;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE c<>0.2);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<>0.2), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE c<>0.2;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE c<>0.2;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE c>0.2;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE c>0.2);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>0.2), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE c>0.2;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE c>0.2;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE c>=0.2;
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE c>=0.2);
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>=0.2), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE c>=0.2;
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE c>=0.2;
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE c<0.2;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE c<0.2);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<0.2), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE c<0.2;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE c<0.2;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE c<=0.2;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE c<=0.2);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<=0.2), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE c<=0.2;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE c<=0.2;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE (NOT c<>0.2
+       OR NOT c<>998)
+  AND (NOT c=0.1
+       OR NOT c=999);
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE (NOT c<>0.2
+          OR NOT c<>998)
+     AND (NOT c=0.1
+          OR NOT c=999));
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT c<>0.2
+          OR NOT c<>998)
+     AND (NOT c=0.1
+          OR NOT c=999)), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE (NOT c<>0.2
+       OR NOT c<>998)
+  AND (NOT c=0.1
+       OR NOT c=999);
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE (NOT c<>0.2
+       OR NOT c<>998)
+  AND (NOT c=0.1
+       OR NOT c=999);
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE (c=0.2
+       OR c=998)
+  AND NOT c=0.1
+  AND NOT c=999;
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE (c=0.2
+          OR c=998)
+     AND NOT c=0.1
+     AND NOT c=999);
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c=0.2
+          OR c=998)
+     AND NOT c=0.1
+     AND NOT c=999), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE (c=0.2
+       OR c=998)
+  AND NOT c=0.1
+  AND NOT c=999;
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE (c=0.2
+       OR c=998)
+  AND NOT c=0.1
+  AND NOT c=999;
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE c IS NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NULL), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE c IS NOT NULL;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE c IS NOT NULL);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NOT NULL), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE c IS NOT NULL;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE c IS NOT NULL;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE c IN (0.2,
+            998) IS TRUE
+  AND c IN (0.1,
+            999) IS NOT TRUE;
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE c IN (0.2,
+               998) IS TRUE
+     AND c IN (0.1,
+               999) IS NOT TRUE);
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN (0.2,
+               998) IS TRUE
+     AND c IN (0.1,
+               999) IS NOT TRUE), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE c IN (0.2,
+            998) IS TRUE
+  AND c IN (0.1,
+            999) IS NOT TRUE;
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE c IN (0.2,
+            998) IS TRUE
+  AND c IN (0.1,
+            999) IS NOT TRUE;
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE c IN (0.2,
+            998) IS FALSE
+  AND c IN (0.1,
+            999) IS NOT FALSE;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE c IN (0.2,
+               998) IS FALSE
+     AND c IN (0.1,
+               999) IS NOT FALSE);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN (0.2,
+               998) IS FALSE
+     AND c IN (0.1,
+               999) IS NOT FALSE), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE c IN (0.2,
+            998) IS FALSE
+  AND c IN (0.1,
+            999) IS NOT FALSE;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE c IN (0.2,
+            998) IS FALSE
+  AND c IN (0.1,
+            999) IS NOT FALSE;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE (c BETWEEN 0.2 AND 0.3)
+  AND (c NOT BETWEEN 0.4 AND 0.5);
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE (c BETWEEN 0.2 AND 0.3)
+     AND (c NOT BETWEEN 0.4 AND 0.5));
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c BETWEEN 0.2 AND 0.3)
+     AND (c NOT BETWEEN 0.4 AND 0.5)), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE (c BETWEEN 0.2 AND 0.3)
+  AND (c NOT BETWEEN 0.4 AND 0.5);
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE (c BETWEEN 0.2 AND 0.3)
+  AND (c NOT BETWEEN 0.4 AND 0.5);
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE (cast(c AS varchar) like '%2%')
+  AND (cast(c AS varchar) not like '%3%');
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE (cast(c AS varchar) like '%2%')
+     AND (cast(c AS varchar) not like '%3%'));
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (cast(c AS varchar) like '%2%')
+     AND (cast(c AS varchar) not like '%3%')), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE (cast(c AS varchar) like '%2%')
+  AND (cast(c AS varchar) not like '%3%');
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE (cast(c AS varchar) like '%2%')
+  AND (cast(c AS varchar) not like '%3%');
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE c IN (0.2,
+            998)
+  AND c NOT IN (0.1,
+                999);
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE c IN (0.2,
+               998)
+     AND c NOT IN (0.1,
+                   999));
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN (0.2,
+               998)
+     AND c NOT IN (0.1,
+                   999)), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE c IN (0.2,
+            998)
+  AND c NOT IN (0.1,
+                999);
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE c IN (0.2,
+            998)
+  AND c NOT IN (0.1,
+                999);
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(0.2),(998)) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0.1),(999)) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(0.2),(998)) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0.1),(999)) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(0.2),(998)) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0.1),(999)) AS t(col))), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(0.2),(998)) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0.1),(999)) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(0.2),(998)) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0.1),(999)) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int=1
+  AND c=0.2;
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int=1
+     AND c=0.2);
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int=1
+     AND c=0.2), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int=1
+  AND c=0.2;
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int=1
+  AND c=0.2;
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int<>1
+  AND c<>0.2;
++-----+
+| c   |
++-----+
+| 0.1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int<>1
+     AND c<>0.2);
++-----+
+| c   |
++-----+
+| 0.1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<>1
+     AND c<>0.2), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int<>1
+  AND c<>0.2;
++-----+
+| c   |
++-----+
+| 0.1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int<>1
+  AND c<>0.2;
++-----+
+| c   |
++-----+
+| 0.1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int>1
+  AND c>0.2;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int>1
+     AND c>0.2);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>1
+     AND c>0.2), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int>1
+  AND c>0.2;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int>1
+  AND c>0.2;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int>=1
+  AND c>=0.2;
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int>=1
+     AND c>=0.2);
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>=1
+     AND c>=0.2), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int>=1
+  AND c>=0.2;
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int>=1
+  AND c>=0.2;
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int<1
+  AND c<0.2;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int<1
+     AND c<0.2);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<1
+     AND c<0.2), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int<1
+  AND c<0.2;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int<1
+  AND c<0.2;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int<=1
+  AND c<=0.2;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int<=1
+     AND c<=0.2);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<=1
+     AND c<=0.2), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int<=1
+  AND c<=0.2;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int<=1
+  AND c<=0.2;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int=999)
+  AND (NOT c<>0.2
+       OR NOT c<>998)
+  AND (NOT c=0.1
+       OR NOT c=999);
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int=999)
+     AND (NOT c<>0.2
+          OR NOT c<>998)
+     AND (NOT c=0.1
+          OR NOT c=999));
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int=999)
+     AND (NOT c<>0.2
+          OR NOT c<>998)
+     AND (NOT c=0.1
+          OR NOT c=999)), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int=999)
+  AND (NOT c<>0.2
+       OR NOT c<>998)
+  AND (NOT c=0.1
+       OR NOT c=999);
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int=999)
+  AND (NOT c<>0.2
+       OR NOT c<>998)
+  AND (NOT c=0.1
+       OR NOT c=999);
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int=999
+  AND (c=0.2
+       OR c=998)
+  AND NOT c=0.1
+  AND NOT c=999;
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int=999
+     AND (c=0.2
+          OR c=998)
+     AND NOT c=0.1
+     AND NOT c=999);
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int=999
+     AND (c=0.2
+          OR c=998)
+     AND NOT c=0.1
+     AND NOT c=999), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int=999
+  AND (c=0.2
+       OR c=998)
+  AND NOT c=0.1
+  AND NOT c=999;
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int=999
+  AND (c=0.2
+       OR c=998)
+  AND NOT c=0.1
+  AND NOT c=999;
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int IS NULL
+     AND c IS NULL);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NULL
+     AND c IS NULL), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int IS NOT NULL
+  AND c IS NOT NULL;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int IS NOT NULL
+     AND c IS NOT NULL);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NOT NULL
+     AND c IS NOT NULL), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int IS NOT NULL
+  AND c IS NOT NULL;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int IS NOT NULL
+  AND c IS NOT NULL;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE
+  AND c IN (0.2,
+            998) IS TRUE
+  AND c IN (0.1,
+            999) IS NOT TRUE;
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE
+     AND c IN (0.2,
+               998) IS TRUE
+     AND c IN (0.1,
+               999) IS NOT TRUE);
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE
+     AND c IN (0.2,
+               998) IS TRUE
+     AND c IN (0.1,
+               999) IS NOT TRUE), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE
+  AND c IN (0.2,
+            998) IS TRUE
+  AND c IN (0.1,
+            999) IS NOT TRUE;
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE
+  AND c IN (0.2,
+            998) IS TRUE
+  AND c IN (0.1,
+            999) IS NOT TRUE;
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE
+  AND c IN (0.2,
+            998) IS FALSE
+  AND c IN (0.1,
+            999) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE
+     AND c IN (0.2,
+               998) IS FALSE
+     AND c IN (0.1,
+               999) IS NOT FALSE);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE
+     AND c IN (0.2,
+               998) IS FALSE
+     AND c IN (0.1,
+               999) IS NOT FALSE), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE
+  AND c IN (0.2,
+            998) IS FALSE
+  AND c IN (0.1,
+            999) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE
+  AND c IN (0.2,
+            998) IS FALSE
+  AND c IN (0.1,
+            999) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN 0.2 AND 0.3)
+  AND (c NOT BETWEEN 0.4 AND 0.5);
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN 0.2 AND 0.3)
+     AND (c NOT BETWEEN 0.4 AND 0.5));
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN 0.2 AND 0.3)
+     AND (c NOT BETWEEN 0.4 AND 0.5)), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN 0.2 AND 0.3)
+  AND (c NOT BETWEEN 0.4 AND 0.5);
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN 0.2 AND 0.3)
+  AND (c NOT BETWEEN 0.4 AND 0.5);
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%')
+  AND (cast(c AS varchar) like '%2%')
+  AND (cast(c AS varchar) not like '%3%');
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%')
+     AND (cast(c AS varchar) like '%2%')
+     AND (cast(c AS varchar) not like '%3%'));
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%')
+     AND (cast(c AS varchar) like '%2%')
+     AND (cast(c AS varchar) not like '%3%')), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%')
+  AND (cast(c AS varchar) like '%2%')
+  AND (cast(c AS varchar) not like '%3%');
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%')
+  AND (cast(c AS varchar) like '%2%')
+  AND (cast(c AS varchar) not like '%3%');
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997)
+  AND c IN (0.2,
+            998)
+  AND c NOT IN (0.1,
+                999);
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997)
+     AND c IN (0.2,
+               998)
+     AND c NOT IN (0.1,
+                   999));
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997)
+     AND c IN (0.2,
+               998)
+     AND c NOT IN (0.1,
+                   999)), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997)
+  AND c IN (0.2,
+            998)
+  AND c NOT IN (0.1,
+                999);
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997)
+  AND c IN (0.2,
+            998)
+  AND c NOT IN (0.1,
+                999);
++-----+
+| c   |
++-----+
+| 0.2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(1),(997)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(0.2),(998)) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0.1),(999)) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(1),(997)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(0.2),(998)) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0.1),(999)) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(1),(997)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(0.2),(998)) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0.1),(999)) AS t(col))), unnest(a_float) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(1),(997)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(0.2),(998)) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0.1),(999)) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(1),(997)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(0.2),(998)) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0.1),(999)) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int=1;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int=1);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int=1), unnest(a_float) AS u(c);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int=1;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int=1;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int<>1;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int<>1);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<>1), unnest(a_float) AS u(c);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int<>1;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int<>1;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int>1;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int>1);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>1), unnest(a_float) AS u(c);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int>1;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int>1;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int>=1;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int>=1);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>=1), unnest(a_float) AS u(c);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int>=1;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int>=1;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int<1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int<1);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<1), unnest(a_float) AS u(c);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int<1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int<1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int<=1;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int<=1);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<=1), unnest(a_float) AS u(c);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int<=1;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int<=1;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int=999);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int=999));
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int=999)), unnest(a_float) AS u(c);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int=999);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int=999);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int=999;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int=999);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int=999), unnest(a_float) AS u(c);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int=999;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int=999;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int IS NULL;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int IS NULL);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NULL), unnest(a_float) AS u(c);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int IS NULL;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int IS NULL;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int IS NOT NULL;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int IS NOT NULL);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NOT NULL), unnest(a_float) AS u(c);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int IS NOT NULL;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int IS NOT NULL;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE), unnest(a_float) AS u(c);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE), unnest(a_float) AS u(c);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4));
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4)), unnest(a_float) AS u(c);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.2 |
+| 0.2 |
+|     |
+|     |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%');
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%'));
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%')), unnest(a_float) AS u(c);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%');
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%');
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B47_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B47_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997));
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B47_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997)), unnest(a_float) AS u(c);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B47_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B47_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B48_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_float) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(997)) AS t(col));
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B48_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c)
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0),(997)) AS t(col)));
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B48_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0),(997)) AS t(col))), unnest(a_float) AS u(c);
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B48_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_float) AS u(c))
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(997)) AS t(col));
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B48_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_float) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(997)) AS t(col));
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE c='S2';
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE c='S2');
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c='S2'), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE c='S2';
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE c='S2';
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE c<>'S2';
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE c<>'S2');
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<>'S2'), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE c<>'S2';
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE c<>'S2';
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE c>'S2';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE c>'S2');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>'S2'), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE c>'S2';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE c>'S2';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE c>='S2';
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE c>='S2');
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>='S2'), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE c>='S2';
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE c>='S2';
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE c<'S2';
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE c<'S2');
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<'S2'), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE c<'S2';
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE c<'S2';
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE c<='S2';
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+| S2 |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE c<='S2');
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+| S2 |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<='S2'), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE c<='S2';
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+| S2 |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE c<='S2';
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+| S2 |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE (NOT c<>'S2'
+       OR NOT c<>'998')
+  AND (NOT c='S1'
+       OR NOT c='999');
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE (NOT c<>'S2'
+          OR NOT c<>'998')
+     AND (NOT c='S1'
+          OR NOT c='999'));
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT c<>'S2'
+          OR NOT c<>'998')
+     AND (NOT c='S1'
+          OR NOT c='999')), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE (NOT c<>'S2'
+       OR NOT c<>'998')
+  AND (NOT c='S1'
+       OR NOT c='999');
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE (NOT c<>'S2'
+       OR NOT c<>'998')
+  AND (NOT c='S1'
+       OR NOT c='999');
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE (c='S2'
+       OR c='998')
+  AND NOT c='S1'
+  AND NOT c='999';
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE (c='S2'
+          OR c='998')
+     AND NOT c='S1'
+     AND NOT c='999');
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c='S2'
+          OR c='998')
+     AND NOT c='S1'
+     AND NOT c='999'), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE (c='S2'
+       OR c='998')
+  AND NOT c='S1'
+  AND NOT c='999';
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE (c='S2'
+       OR c='998')
+  AND NOT c='S1'
+  AND NOT c='999';
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE c IS NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NULL), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE c IS NOT NULL;
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+| S2 |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE c IS NOT NULL);
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+| S2 |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NOT NULL), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE c IS NOT NULL;
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+| S2 |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE c IS NOT NULL;
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+| S2 |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE c IN ('S2',
+            '998') IS TRUE
+  AND c IN ('S1',
+            '999') IS NOT TRUE;
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE c IN ('S2',
+               '998') IS TRUE
+     AND c IN ('S1',
+               '999') IS NOT TRUE);
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('S2',
+               '998') IS TRUE
+     AND c IN ('S1',
+               '999') IS NOT TRUE), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE c IN ('S2',
+            '998') IS TRUE
+  AND c IN ('S1',
+            '999') IS NOT TRUE;
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE c IN ('S2',
+            '998') IS TRUE
+  AND c IN ('S1',
+            '999') IS NOT TRUE;
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE c IN ('S2',
+            '998') IS FALSE
+  AND c IN ('S1',
+            '999') IS NOT FALSE;
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE c IN ('S2',
+               '998') IS FALSE
+     AND c IN ('S1',
+               '999') IS NOT FALSE);
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('S2',
+               '998') IS FALSE
+     AND c IN ('S1',
+               '999') IS NOT FALSE), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE c IN ('S2',
+            '998') IS FALSE
+  AND c IN ('S1',
+            '999') IS NOT FALSE;
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE c IN ('S2',
+            '998') IS FALSE
+  AND c IN ('S1',
+            '999') IS NOT FALSE;
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE (c BETWEEN 'S2' AND 'S3')
+  AND (c NOT BETWEEN 'S4' AND 'S5');
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE (c BETWEEN 'S2' AND 'S3')
+     AND (c NOT BETWEEN 'S4' AND 'S5'));
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c BETWEEN 'S2' AND 'S3')
+     AND (c NOT BETWEEN 'S4' AND 'S5')), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE (c BETWEEN 'S2' AND 'S3')
+  AND (c NOT BETWEEN 'S4' AND 'S5');
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE (c BETWEEN 'S2' AND 'S3')
+  AND (c NOT BETWEEN 'S4' AND 'S5');
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE (cast(c AS varchar) like '%2%')
+  AND (cast(c AS varchar) not like '%3%');
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE (cast(c AS varchar) like '%2%')
+     AND (cast(c AS varchar) not like '%3%'));
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (cast(c AS varchar) like '%2%')
+     AND (cast(c AS varchar) not like '%3%')), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE (cast(c AS varchar) like '%2%')
+  AND (cast(c AS varchar) not like '%3%');
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE (cast(c AS varchar) like '%2%')
+  AND (cast(c AS varchar) not like '%3%');
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE c IN ('S2',
+            '998')
+  AND c NOT IN ('S1',
+                '999');
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE c IN ('S2',
+               '998')
+     AND c NOT IN ('S1',
+                   '999'));
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('S2',
+               '998')
+     AND c NOT IN ('S1',
+                   '999')), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE c IN ('S2',
+            '998')
+  AND c NOT IN ('S1',
+                '999');
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE c IN ('S2',
+            '998')
+  AND c NOT IN ('S1',
+                '999');
++----+
+| c  |
++----+
+| S2 |
+| S2 |
+| S2 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES('S2'),('998')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('S1'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES('S2'),('998')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('S1'),('999')) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES('S2'),('998')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('S1'),('999')) AS t(col))), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES('S2'),('998')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('S1'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES('S2'),('998')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('S1'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int=1
+  AND c='S2';
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int=1
+     AND c='S2');
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int=1
+     AND c='S2'), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int=1
+  AND c='S2';
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int=1
+  AND c='S2';
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int<>1
+  AND c<>'S2';
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int<>1
+     AND c<>'S2');
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<>1
+     AND c<>'S2'), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int<>1
+  AND c<>'S2';
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int<>1
+  AND c<>'S2';
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int>1
+  AND c>'S2';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int>1
+     AND c>'S2');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>1
+     AND c>'S2'), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int>1
+  AND c>'S2';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int>1
+  AND c>'S2';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int>=1
+  AND c>='S2';
++----+
+| c  |
++----+
+| S2 |
+| S2 |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int>=1
+     AND c>='S2');
++----+
+| c  |
++----+
+| S2 |
+| S2 |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>=1
+     AND c>='S2'), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int>=1
+  AND c>='S2';
++----+
+| c  |
++----+
+| S2 |
+| S2 |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int>=1
+  AND c>='S2';
++----+
+| c  |
++----+
+| S2 |
+| S2 |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int<1
+  AND c<'S2';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int<1
+     AND c<'S2');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<1
+     AND c<'S2'), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int<1
+  AND c<'S2';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int<1
+  AND c<'S2';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int<=1
+  AND c<='S2';
++----+
+| c  |
++----+
+| S1 |
+| S2 |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int<=1
+     AND c<='S2');
++----+
+| c  |
++----+
+| S1 |
+| S2 |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<=1
+     AND c<='S2'), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int<=1
+  AND c<='S2';
++----+
+| c  |
++----+
+| S1 |
+| S2 |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int<=1
+  AND c<='S2';
++----+
+| c  |
++----+
+| S1 |
+| S2 |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int='999')
+  AND (NOT c<>'S2'
+       OR NOT c<>'998')
+  AND (NOT c='S1'
+       OR NOT c='999');
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int='999')
+     AND (NOT c<>'S2'
+          OR NOT c<>'998')
+     AND (NOT c='S1'
+          OR NOT c='999'));
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int='999')
+     AND (NOT c<>'S2'
+          OR NOT c<>'998')
+     AND (NOT c='S1'
+          OR NOT c='999')), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int='999')
+  AND (NOT c<>'S2'
+       OR NOT c<>'998')
+  AND (NOT c='S1'
+       OR NOT c='999');
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int='999')
+  AND (NOT c<>'S2'
+       OR NOT c<>'998')
+  AND (NOT c='S1'
+       OR NOT c='999');
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int='999'
+  AND (c='S2'
+       OR c='998')
+  AND NOT c='S1'
+  AND NOT c='999';
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int='999'
+     AND (c='S2'
+          OR c='998')
+     AND NOT c='S1'
+     AND NOT c='999');
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int='999'
+     AND (c='S2'
+          OR c='998')
+     AND NOT c='S1'
+     AND NOT c='999'), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int='999'
+  AND (c='S2'
+       OR c='998')
+  AND NOT c='S1'
+  AND NOT c='999';
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int='999'
+  AND (c='S2'
+       OR c='998')
+  AND NOT c='S1'
+  AND NOT c='999';
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int IS NULL
+     AND c IS NULL);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NULL
+     AND c IS NULL), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int IS NOT NULL
+  AND c IS NOT NULL;
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S2 |
+| S2 |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int IS NOT NULL
+     AND c IS NOT NULL);
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S2 |
+| S2 |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NOT NULL
+     AND c IS NOT NULL), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int IS NOT NULL
+  AND c IS NOT NULL;
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S2 |
+| S2 |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int IS NOT NULL
+  AND c IS NOT NULL;
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S2 |
+| S2 |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE
+  AND c IN ('S2',
+            '998') IS TRUE
+  AND c IN ('S1',
+            '999') IS NOT TRUE;
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE
+     AND c IN ('S2',
+               '998') IS TRUE
+     AND c IN ('S1',
+               '999') IS NOT TRUE);
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE
+     AND c IN ('S2',
+               '998') IS TRUE
+     AND c IN ('S1',
+               '999') IS NOT TRUE), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE
+  AND c IN ('S2',
+            '998') IS TRUE
+  AND c IN ('S1',
+            '999') IS NOT TRUE;
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE
+  AND c IN ('S2',
+            '998') IS TRUE
+  AND c IN ('S1',
+            '999') IS NOT TRUE;
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE
+  AND c IN ('S2',
+            '998') IS FALSE
+  AND c IN ('S1',
+            '999') IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE
+     AND c IN ('S2',
+               '998') IS FALSE
+     AND c IN ('S1',
+               '999') IS NOT FALSE);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE
+     AND c IN ('S2',
+               '998') IS FALSE
+     AND c IN ('S1',
+               '999') IS NOT FALSE), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE
+  AND c IN ('S2',
+            '998') IS FALSE
+  AND c IN ('S1',
+            '999') IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE
+  AND c IN ('S2',
+            '998') IS FALSE
+  AND c IN ('S1',
+            '999') IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN 'S2' AND 'S3')
+  AND (c NOT BETWEEN 'S4' AND 'S5');
++----+
+| c  |
++----+
+| S2 |
+| S2 |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN 'S2' AND 'S3')
+     AND (c NOT BETWEEN 'S4' AND 'S5'));
++----+
+| c  |
++----+
+| S2 |
+| S2 |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN 'S2' AND 'S3')
+     AND (c NOT BETWEEN 'S4' AND 'S5')), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN 'S2' AND 'S3')
+  AND (c NOT BETWEEN 'S4' AND 'S5');
++----+
+| c  |
++----+
+| S2 |
+| S2 |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN 'S2' AND 'S3')
+  AND (c NOT BETWEEN 'S4' AND 'S5');
++----+
+| c  |
++----+
+| S2 |
+| S2 |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%')
+  AND (cast(c AS varchar) like '%2%')
+  AND (cast(c AS varchar) not like '%3%');
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%')
+     AND (cast(c AS varchar) like '%2%')
+     AND (cast(c AS varchar) not like '%3%'));
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%')
+     AND (cast(c AS varchar) like '%2%')
+     AND (cast(c AS varchar) not like '%3%')), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%')
+  AND (cast(c AS varchar) like '%2%')
+  AND (cast(c AS varchar) not like '%3%');
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%')
+  AND (cast(c AS varchar) like '%2%')
+  AND (cast(c AS varchar) not like '%3%');
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997)
+  AND c IN ('S2',
+            '998')
+  AND c NOT IN ('S1',
+                '999');
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997)
+     AND c IN ('S2',
+               '998')
+     AND c NOT IN ('S1',
+                   '999'));
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997)
+     AND c IN ('S2',
+               '998')
+     AND c NOT IN ('S1',
+                   '999')), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997)
+  AND c IN ('S2',
+            '998')
+  AND c NOT IN ('S1',
+                '999');
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997)
+  AND c IN ('S2',
+            '998')
+  AND c NOT IN ('S1',
+                '999');
++----+
+| c  |
++----+
+| S2 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(1),(997)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES('S2'),('998')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('S1'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(1),(997)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES('S2'),('998')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('S1'),('999')) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(1),(997)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES('S2'),('998')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('S1'),('999')) AS t(col))), unnest(a_str) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(1),(997)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES('S2'),('998')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('S1'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(1),(997)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES('S2'),('998')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('S1'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int=1;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int=1);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int=1), unnest(a_str) AS u(c);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int=1;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int=1;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int<>1;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int<>1);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<>1), unnest(a_str) AS u(c);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int<>1;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int<>1;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int>1;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int>1);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>1), unnest(a_str) AS u(c);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int>1;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int>1;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int>=1;
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+|    |
+|    |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int>=1);
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+|    |
+|    |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>=1), unnest(a_str) AS u(c);
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+|    |
+|    |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int>=1;
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+|    |
+|    |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int>=1;
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+|    |
+|    |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int<1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int<1);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<1), unnest(a_str) AS u(c);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int<1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int<1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int<=1;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int<=1);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<=1), unnest(a_str) AS u(c);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int<=1;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int<=1;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int='999');
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int='999'));
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int='999')), unnest(a_str) AS u(c);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int='999');
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int='999');
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int='999';
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int='999');
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int='999'), unnest(a_str) AS u(c);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int='999';
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int='999';
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int IS NULL;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int IS NULL);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NULL), unnest(a_str) AS u(c);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int IS NULL;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int IS NULL;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int IS NOT NULL;
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+|    |
+|    |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int IS NOT NULL);
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+|    |
+|    |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NOT NULL), unnest(a_str) AS u(c);
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+|    |
+|    |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int IS NOT NULL;
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+|    |
+|    |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int IS NOT NULL;
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+|    |
+|    |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE), unnest(a_str) AS u(c);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE;
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE), unnest(a_str) AS u(c);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4);
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+|    |
+|    |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4));
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+|    |
+|    |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4)), unnest(a_str) AS u(c);
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+|    |
+|    |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4);
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+|    |
+|    |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4);
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S2 |
+| S2 |
+|    |
+|    |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%');
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%'));
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%')), unnest(a_str) AS u(c);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%');
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%');
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B47_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B47_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997));
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B47_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997)), unnest(a_str) AS u(c);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B47_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B47_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B48_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_str) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(997)) AS t(col));
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B48_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c)
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0),(997)) AS t(col)));
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B48_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0),(997)) AS t(col))), unnest(a_str) AS u(c);
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B48_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_str) AS u(c))
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(997)) AS t(col));
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B48_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_str) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(997)) AS t(col));
++----+
+| c  |
++----+
+| S1 |
+| S2 |
+|    |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE c='S1';
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE c='S1');
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B1_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c='S1'), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE c='S1';
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE c='S1';
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE c<>'S1';
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| 1    |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE c<>'S1');
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| 1    |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B2_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<>'S1'), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE c<>'S1';
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| 1    |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE c<>'S1';
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| 1    |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE c>'S1';
++------+
+| c    |
++------+
+| true |
+| true |
+| true |
++------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE c>'S1');
++------+
+| c    |
++------+
+| true |
+| true |
+| true |
++------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B3_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>'S1'), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B3_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE c>'S1';
++------+
+| c    |
++------+
+| true |
+| true |
+| true |
++------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B3_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE c>'S1';
++------+
+| c    |
++------+
+| true |
+| true |
+| true |
++------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE c>='S1';
++------+
+| c    |
++------+
+| S1   |
+| S1   |
+| S1   |
+| true |
+| true |
+| true |
++------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE c>='S1');
++------+
+| c    |
++------+
+| S1   |
+| S1   |
+| S1   |
+| true |
+| true |
+| true |
++------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B4_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>='S1'), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B4_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE c>='S1';
++------+
+| c    |
++------+
+| S1   |
+| S1   |
+| S1   |
+| true |
+| true |
+| true |
++------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B4_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE c>='S1';
++------+
+| c    |
++------+
+| S1   |
+| S1   |
+| S1   |
+| true |
+| true |
+| true |
++------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE c<'S1';
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 1   |
+| 1   |
+| 1   |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE c<'S1');
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 1   |
+| 1   |
+| 1   |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B5_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<'S1'), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B5_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE c<'S1';
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 1   |
+| 1   |
+| 1   |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B5_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE c<'S1';
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 1   |
+| 1   |
+| 1   |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE c<='S1';
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 1   |
+| 1   |
+| 1   |
+| S1  |
+| S1  |
+| S1  |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE c<='S1');
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 1   |
+| 1   |
+| 1   |
+| S1  |
+| S1  |
+| S1  |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B6_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<='S1'), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B6_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE c<='S1';
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 1   |
+| 1   |
+| 1   |
+| S1  |
+| S1  |
+| S1  |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B6_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE c<='S1';
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 1   |
+| 1   |
+| 1   |
+| S1  |
+| S1  |
+| S1  |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE (NOT c<>'S1'
+       OR NOT c<>'998')
+  AND (NOT c='S2'
+       OR NOT c='999');
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE (NOT c<>'S1'
+          OR NOT c<>'998')
+     AND (NOT c='S2'
+          OR NOT c='999'));
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B7_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT c<>'S1'
+          OR NOT c<>'998')
+     AND (NOT c='S2'
+          OR NOT c='999')), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B7_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE (NOT c<>'S1'
+       OR NOT c<>'998')
+  AND (NOT c='S2'
+       OR NOT c='999');
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B7_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE (NOT c<>'S1'
+       OR NOT c<>'998')
+  AND (NOT c='S2'
+       OR NOT c='999');
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE (c='S1'
+       OR c='998')
+  AND NOT c='S2'
+  AND NOT c='999';
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE (c='S1'
+          OR c='998')
+     AND NOT c='S2'
+     AND NOT c='999');
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B8_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c='S1'
+          OR c='998')
+     AND NOT c='S2'
+     AND NOT c='999'), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE (c='S1'
+       OR c='998')
+  AND NOT c='S2'
+  AND NOT c='999';
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE (c='S1'
+       OR c='998')
+  AND NOT c='S2'
+  AND NOT c='999';
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE c IS NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B9_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NULL), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B9_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B9_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE c IS NOT NULL;
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| S1   |
+| true |
+| true |
+| true |
++------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE c IS NOT NULL);
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| S1   |
+| true |
+| true |
+| true |
++------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B10_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NOT NULL), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B10_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE c IS NOT NULL;
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| S1   |
+| true |
+| true |
+| true |
++------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B10_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE c IS NOT NULL;
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| S1   |
+| true |
+| true |
+| true |
++------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE c IN ('S1',
+            '998') IS TRUE
+  AND c IN ('S2',
+            '999') IS NOT TRUE;
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE c IN ('S1',
+               '998') IS TRUE
+     AND c IN ('S2',
+               '999') IS NOT TRUE);
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B11_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('S1',
+               '998') IS TRUE
+     AND c IN ('S2',
+               '999') IS NOT TRUE), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B11_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE c IN ('S1',
+            '998') IS TRUE
+  AND c IN ('S2',
+            '999') IS NOT TRUE;
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B11_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE c IN ('S1',
+            '998') IS TRUE
+  AND c IN ('S2',
+            '999') IS NOT TRUE;
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE c IN ('S1',
+            '998') IS FALSE
+  AND c IN ('S2',
+            '999') IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE c IN ('S1',
+               '998') IS FALSE
+     AND c IN ('S2',
+               '999') IS NOT FALSE);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B12_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('S1',
+               '998') IS FALSE
+     AND c IN ('S2',
+               '999') IS NOT FALSE), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B12_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE c IN ('S1',
+            '998') IS FALSE
+  AND c IN ('S2',
+            '999') IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B12_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE c IN ('S1',
+            '998') IS FALSE
+  AND c IN ('S2',
+            '999') IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE (c BETWEEN 'S1' AND 'S2')
+  AND (c NOT BETWEEN 'S3' AND 'S4');
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B13_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE (c BETWEEN 'S1' AND 'S2')
+     AND (c NOT BETWEEN 'S3' AND 'S4'));
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B13_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c BETWEEN 'S1' AND 'S2')
+     AND (c NOT BETWEEN 'S3' AND 'S4')), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B13_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE (c BETWEEN 'S1' AND 'S2')
+  AND (c NOT BETWEEN 'S3' AND 'S4');
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B13_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE (c BETWEEN 'S1' AND 'S2')
+  AND (c NOT BETWEEN 'S3' AND 'S4');
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE (cast(c AS varchar) like '%1%')
+  AND (cast(c AS varchar) not like '%2%');
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 1   |
+| 1   |
+| 1   |
+| S1  |
+| S1  |
+| S1  |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE (cast(c AS varchar) like '%1%')
+     AND (cast(c AS varchar) not like '%2%'));
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 1   |
+| 1   |
+| 1   |
+| S1  |
+| S1  |
+| S1  |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B14_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (cast(c AS varchar) like '%1%')
+     AND (cast(c AS varchar) not like '%2%')), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B14_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE (cast(c AS varchar) like '%1%')
+  AND (cast(c AS varchar) not like '%2%');
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 1   |
+| 1   |
+| 1   |
+| S1  |
+| S1  |
+| S1  |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B14_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE (cast(c AS varchar) like '%1%')
+  AND (cast(c AS varchar) not like '%2%');
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+| 0.1 |
+| 1   |
+| 1   |
+| 1   |
+| S1  |
+| S1  |
+| S1  |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE c IN ('S1',
+            '998')
+  AND c NOT IN ('S2',
+                '999');
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B15_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE c IN ('S1',
+               '998')
+     AND c NOT IN ('S2',
+                   '999'));
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B15_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('S1',
+               '998')
+     AND c NOT IN ('S2',
+                   '999')), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B15_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE c IN ('S1',
+            '998')
+  AND c NOT IN ('S2',
+                '999');
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B15_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE c IN ('S1',
+            '998')
+  AND c NOT IN ('S2',
+                '999');
++----+
+| c  |
++----+
+| S1 |
+| S1 |
+| S1 |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B16_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES('S1'),('998')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('S2'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B16_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES('S1'),('998')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('S2'),('999')) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B16_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES('S1'),('998')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('S2'),('999')) AS t(col))), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B16_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES('S1'),('998')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('S2'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B16_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES('S1'),('998')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('S2'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int=1
+  AND c='S1';
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int=1
+     AND c='S1');
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B17_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int=1
+     AND c='S1'), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B17_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int=1
+  AND c='S1';
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B17_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int=1
+  AND c='S1';
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int<>1
+  AND c<>'S1';
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| true |
++------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B18_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int<>1
+     AND c<>'S1');
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| true |
++------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B18_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<>1
+     AND c<>'S1'), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B18_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int<>1
+  AND c<>'S1';
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| true |
++------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B18_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int<>1
+  AND c<>'S1';
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| true |
++------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int>1
+  AND c>'S1';
++------+
+| c    |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int>1
+     AND c>'S1');
++------+
+| c    |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B19_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>1
+     AND c>'S1'), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int>1
+  AND c>'S1';
++------+
+| c    |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int>1
+  AND c>'S1';
++------+
+| c    |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int>=1
+  AND c>='S1';
++------+
+| c    |
++------+
+| S1   |
+| S1   |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int>=1
+     AND c>='S1');
++------+
+| c    |
++------+
+| S1   |
+| S1   |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B20_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>=1
+     AND c>='S1'), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int>=1
+  AND c>='S1';
++------+
+| c    |
++------+
+| S1   |
+| S1   |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int>=1
+  AND c>='S1';
++------+
+| c    |
++------+
+| S1   |
+| S1   |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int<1
+  AND c<'S1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int<1
+     AND c<'S1');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B21_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<1
+     AND c<'S1'), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B21_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int<1
+  AND c<'S1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B21_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int<1
+  AND c<'S1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int<=1
+  AND c<='S1';
++-----+
+| c   |
++-----+
+| 0.1 |
+| 1   |
+| S1  |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B22_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int<=1
+     AND c<='S1');
++-----+
+| c   |
++-----+
+| 0.1 |
+| 1   |
+| S1  |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B22_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<=1
+     AND c<='S1'), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B22_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int<=1
+  AND c<='S1';
++-----+
+| c   |
++-----+
+| 0.1 |
+| 1   |
+| S1  |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B22_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int<=1
+  AND c<='S1';
++-----+
+| c   |
++-----+
+| 0.1 |
+| 1   |
+| S1  |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int='999')
+  AND (NOT c<>'S1'
+       OR NOT c<>'998')
+  AND (NOT c='S2'
+       OR NOT c='999');
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int='999')
+     AND (NOT c<>'S1'
+          OR NOT c<>'998')
+     AND (NOT c='S2'
+          OR NOT c='999'));
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B23_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int='999')
+     AND (NOT c<>'S1'
+          OR NOT c<>'998')
+     AND (NOT c='S2'
+          OR NOT c='999')), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B23_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int='999')
+  AND (NOT c<>'S1'
+       OR NOT c<>'998')
+  AND (NOT c='S2'
+       OR NOT c='999');
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B23_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int='999')
+  AND (NOT c<>'S1'
+       OR NOT c<>'998')
+  AND (NOT c='S2'
+       OR NOT c='999');
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int='999'
+  AND (c='S1'
+       OR c='998')
+  AND NOT c='S2'
+  AND NOT c='999';
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int='999'
+     AND (c='S1'
+          OR c='998')
+     AND NOT c='S2'
+     AND NOT c='999');
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B24_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int='999'
+     AND (c='S1'
+          OR c='998')
+     AND NOT c='S2'
+     AND NOT c='999'), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B24_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int='999'
+  AND (c='S1'
+       OR c='998')
+  AND NOT c='S2'
+  AND NOT c='999';
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B24_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int='999'
+  AND (c='S1'
+       OR c='998')
+  AND NOT c='S2'
+  AND NOT c='999';
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B25_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int IS NULL
+     AND c IS NULL);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B25_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NULL
+     AND c IS NULL), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B25_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B25_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int IS NOT NULL
+  AND c IS NOT NULL;
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| true |
+| true |
++------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int IS NOT NULL
+     AND c IS NOT NULL);
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| true |
+| true |
++------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B26_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NOT NULL
+     AND c IS NOT NULL), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B26_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int IS NOT NULL
+  AND c IS NOT NULL;
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| true |
+| true |
++------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B26_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int IS NOT NULL
+  AND c IS NOT NULL;
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| true |
+| true |
++------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE
+  AND c IN ('S1',
+            '998') IS TRUE
+  AND c IN ('S2',
+            '999') IS NOT TRUE;
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B27_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE
+     AND c IN ('S1',
+               '998') IS TRUE
+     AND c IN ('S2',
+               '999') IS NOT TRUE);
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B27_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE
+     AND c IN ('S1',
+               '998') IS TRUE
+     AND c IN ('S2',
+               '999') IS NOT TRUE), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B27_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE
+  AND c IN ('S1',
+            '998') IS TRUE
+  AND c IN ('S2',
+            '999') IS NOT TRUE;
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B27_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE
+  AND c IN ('S1',
+            '998') IS TRUE
+  AND c IN ('S2',
+            '999') IS NOT TRUE;
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE
+  AND c IN ('S1',
+            '998') IS FALSE
+  AND c IN ('S2',
+            '999') IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B28_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE
+     AND c IN ('S1',
+               '998') IS FALSE
+     AND c IN ('S2',
+               '999') IS NOT FALSE);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B28_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE
+     AND c IN ('S1',
+               '998') IS FALSE
+     AND c IN ('S2',
+               '999') IS NOT FALSE), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B28_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE
+  AND c IN ('S1',
+            '998') IS FALSE
+  AND c IN ('S2',
+            '999') IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B28_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE
+  AND c IN ('S1',
+            '998') IS FALSE
+  AND c IN ('S2',
+            '999') IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B29_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN 'S1' AND 'S2')
+  AND (c NOT BETWEEN 'S3' AND 'S4');
++----+
+| c  |
++----+
+| S1 |
+| S1 |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B29_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN 'S1' AND 'S2')
+     AND (c NOT BETWEEN 'S3' AND 'S4'));
++----+
+| c  |
++----+
+| S1 |
+| S1 |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B29_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN 'S1' AND 'S2')
+     AND (c NOT BETWEEN 'S3' AND 'S4')), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B29_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN 'S1' AND 'S2')
+  AND (c NOT BETWEEN 'S3' AND 'S4');
++----+
+| c  |
++----+
+| S1 |
+| S1 |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B29_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN 'S1' AND 'S2')
+  AND (c NOT BETWEEN 'S3' AND 'S4');
++----+
+| c  |
++----+
+| S1 |
+| S1 |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B30_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%')
+  AND (cast(c AS varchar) like '%1%')
+  AND (cast(c AS varchar) not like '%2%');
++-----+
+| c   |
++-----+
+| 0.1 |
+| 1   |
+| S1  |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B30_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%')
+     AND (cast(c AS varchar) like '%1%')
+     AND (cast(c AS varchar) not like '%2%'));
++-----+
+| c   |
++-----+
+| 0.1 |
+| 1   |
+| S1  |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B30_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%')
+     AND (cast(c AS varchar) like '%1%')
+     AND (cast(c AS varchar) not like '%2%')), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B30_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%')
+  AND (cast(c AS varchar) like '%1%')
+  AND (cast(c AS varchar) not like '%2%');
++-----+
+| c   |
++-----+
+| 0.1 |
+| 1   |
+| S1  |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B30_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%')
+  AND (cast(c AS varchar) like '%1%')
+  AND (cast(c AS varchar) not like '%2%');
++-----+
+| c   |
++-----+
+| 0.1 |
+| 1   |
+| S1  |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B31_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997)
+  AND c IN ('S1',
+            '998')
+  AND c NOT IN ('S2',
+                '999');
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B31_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997)
+     AND c IN ('S1',
+               '998')
+     AND c NOT IN ('S2',
+                   '999'));
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B31_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997)
+     AND c IN ('S1',
+               '998')
+     AND c NOT IN ('S2',
+                   '999')), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B31_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997)
+  AND c IN ('S1',
+            '998')
+  AND c NOT IN ('S2',
+                '999');
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B31_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997)
+  AND c IN ('S1',
+            '998')
+  AND c NOT IN ('S2',
+                '999');
++----+
+| c  |
++----+
+| S1 |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B32_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(1),(997)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES('S1'),('998')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('S2'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B32_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(1),(997)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES('S1'),('998')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('S2'),('999')) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B32_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(1),(997)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES('S1'),('998')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('S2'),('999')) AS t(col))), unnest(a_mixed) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B32_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(1),(997)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES('S1'),('998')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('S2'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B32_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(1),(997)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES('S1'),('998')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('S2'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B33_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int=1;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B33_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int=1);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B33_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int=1), unnest(a_mixed) AS u(c);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B33_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int=1;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B33_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int=1;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B34_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int<>1;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B34_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int<>1);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B34_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<>1), unnest(a_mixed) AS u(c);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B34_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int<>1;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B34_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int<>1;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B35_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int>1;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B35_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int>1);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B35_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>1), unnest(a_mixed) AS u(c);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B35_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int>1;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B35_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int>1;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B36_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int>=1;
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| true |
+| true |
+|      |
+|      |
++------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B36_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int>=1);
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| true |
+| true |
+|      |
+|      |
++------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B36_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int>=1), unnest(a_mixed) AS u(c);
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| true |
+| true |
+|      |
+|      |
++------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B36_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int>=1;
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| true |
+| true |
+|      |
+|      |
++------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B36_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int>=1;
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| true |
+| true |
+|      |
+|      |
++------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B37_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int<1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B37_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int<1);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B37_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<1), unnest(a_mixed) AS u(c);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B37_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int<1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B37_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int<1;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B38_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int<=1;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B38_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int<=1);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B38_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int<=1), unnest(a_mixed) AS u(c);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B38_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int<=1;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B38_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int<=1;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B39_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int='999');
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B39_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int='999'));
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B39_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT s_int<>1
+          OR NOT s_int<>997)
+     AND (NOT s_int=0
+          OR NOT s_int='999')), unnest(a_mixed) AS u(c);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B39_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int='999');
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B39_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE (NOT s_int<>1
+       OR NOT s_int<>997)
+  AND (NOT s_int=0
+       OR NOT s_int='999');
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B40_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int='999';
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B40_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int='999');
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B40_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int=1
+          OR s_int=997)
+     AND NOT s_int=0
+     AND NOT s_int='999'), unnest(a_mixed) AS u(c);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B40_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int='999';
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B40_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE (s_int=1
+       OR s_int=997)
+  AND NOT s_int=0
+  AND NOT s_int='999';
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B41_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int IS NULL;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B41_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int IS NULL);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B41_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NULL), unnest(a_mixed) AS u(c);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B41_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int IS NULL;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B41_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int IS NULL;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B42_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int IS NOT NULL;
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| true |
+| true |
+|      |
+|      |
++------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B42_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int IS NOT NULL);
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| true |
+| true |
+|      |
+|      |
++------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B42_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IS NOT NULL), unnest(a_mixed) AS u(c);
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| true |
+| true |
+|      |
+|      |
++------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B42_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int IS NOT NULL;
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| true |
+| true |
+|      |
+|      |
++------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B42_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int IS NOT NULL;
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| true |
+| true |
+|      |
+|      |
++------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B43_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B43_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B43_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS TRUE
+     AND s_int IN (0,
+                   997) IS NOT TRUE), unnest(a_mixed) AS u(c);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B43_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B43_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int IN (1,
+                996) IS TRUE
+  AND s_int IN (0,
+                997) IS NOT TRUE;
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B44_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B44_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B44_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996) IS FALSE
+     AND s_int IN (0,
+                   997) IS NOT FALSE), unnest(a_mixed) AS u(c);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B44_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B44_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int IN (1,
+                996) IS FALSE
+  AND s_int IN (0,
+                997) IS NOT FALSE;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B45_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4);
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| true |
+| true |
+|      |
+|      |
++------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B45_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4));
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| true |
+| true |
+|      |
+|      |
++------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B45_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (s_int BETWEEN 1 AND 2)
+     AND (s_int NOT BETWEEN 3 AND 4)), unnest(a_mixed) AS u(c);
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| true |
+| true |
+|      |
+|      |
++------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B45_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4);
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| true |
+| true |
+|      |
+|      |
++------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B45_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE (s_int BETWEEN 1 AND 2)
+  AND (s_int NOT BETWEEN 3 AND 4);
++------+
+| c    |
++------+
+| 0.1  |
+| 0.1  |
+| 1    |
+| 1    |
+| S1   |
+| S1   |
+| true |
+| true |
+|      |
+|      |
++------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B46_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%');
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B46_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%'));
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B46_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (cast(s_int AS varchar) like '%1%')
+     AND (cast(s_int AS varchar) not like '%3%')), unnest(a_mixed) AS u(c);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B46_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%');
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B46_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE (cast(s_int AS varchar) like '%1%')
+  AND (cast(s_int AS varchar) not like '%3%');
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B47_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B47_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997));
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B47_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN (1,
+                   996)
+     AND s_int NOT IN (0,
+                       997)), unnest(a_mixed) AS u(c);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B47_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B47_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int IN (1,
+                996)
+  AND s_int NOT IN (0,
+                    997);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B48_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(a_mixed) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(997)) AS t(col));
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B48_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c)
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0),(997)) AS t(col)));
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B48_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE s_int IN
+       (SELECT col
+        FROM (
+              VALUES(1),(996)) AS t(col))
+     AND s_int NOT IN
+       (SELECT col
+        FROM (
+              VALUES(0),(997)) AS t(col))), unnest(a_mixed) AS u(c);
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B48_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(a_mixed) AS u(c))
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(997)) AS t(col));
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B48_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(a_mixed) AS u(c)
+WHERE s_int IN
+    (SELECT col
+     FROM (
+           VALUES(1),(996)) AS t(col))
+  AND s_int NOT IN
+    (SELECT col
+     FROM (
+           VALUES(0),(997)) AS t(col));
++------+
+| c    |
++------+
+| 0.1  |
+| 1    |
+| S1   |
+| true |
+|      |
++------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 1201 Positive tests: 1001 Negative tests: 200
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql_ops.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql_ops.iq
new file mode 100644
index 000000000000..fb86811362a6
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql_ops.iq
@@ -0,0 +1,309 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaUnnest/array&numMergeBuffers=3
+!set outputformat mysql
+SELECT *
+FROM test_unnest;
++-------------------------+-------+--------+--------------+--------------+------------------+----------------+--------------------+---------+--------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| __time                  | s_int | s_null | a_bool       | a_int        | a_float          | a_str          | a_null             | a_empty | a_mixed                  | a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------+-------+--------+--------------+--------------+------------------+----------------+--------------------+---------+--------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| 2022-01-01 00:00:00.000 |     1 |        | [1, 0, null] | [1, 2, null] | [0.1, 0.2, null] | [S1, S2, null] | [null, null, null] | []      | [true, 1, 0.1, S1, null] | [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| 2022-02-01 00:00:00.000 |     2 |        | [null, 1, 0] | [null, 1, 2] | [null, 0.1, 0.2] | [null, S1, S2] | [null, null, null] | []      | [null, true, 1, 0.1, S1] | [[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"],[[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"],[[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"]]]] |
+| 2022-03-01 00:00:00.000 |       |        | [0, null, 1] | [2, null, 1] | [0.2, null, 0.1] | [S2, null, S1] | [null, null, null] | []      | [S1, null, true, 1, 0.1] | [[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1],[[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1],[[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1]]]] |
++-------------------------+-------+--------+--------------+--------------+------------------+----------------+--------------------+---------+--------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c+c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((c+c)<99999
+       OR (c+c) IS NULL);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   4 |
+|   4 |
+|   4 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c+s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((c+s_int)<99999
+       OR (c+s_int) IS NULL);
++-----+
+| col |
++-----+
+|   2 |
+|   3 |
+|   3 |
+|   4 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c-c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((c-c)<99999
+       OR (c-c) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c-s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((c-s_int)<99999
+       OR (c-s_int) IS NULL);
++-----+
+| col |
++-----+
+|  -1 |
+|   0 |
+|   0 |
+|   1 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c*c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((c*c)<99999
+       OR (c*c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   4 |
+|   4 |
+|   4 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c*s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((c*s_int)<99999
+       OR (c*s_int) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|   2 |
+|   4 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c/c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((c/c)<99999
+       OR (c/c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c/s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((c/s_int)<99999
+       OR (c/s_int) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   1 |
+|   2 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A2_B1_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c||c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((c||c)<'99999'
+       OR (c||c) IS NULL);
++-----+
+| col |
++-----+
+| 11  |
+| 11  |
+| 11  |
+| 22  |
+| 22  |
+| 22  |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A2_B1_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c||s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((c||s_int)<'99999'
+       OR (c||s_int) IS NULL);
++-----+
+| col |
++-----+
+| 11  |
+| 12  |
+| 21  |
+| 22  |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 11 Positive tests: 11 Negative tests: 0
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql_other_funcs.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql_other_funcs.iq
new file mode 100644
index 000000000000..a9eb5526ddf8
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql_other_funcs.iq
@@ -0,0 +1,20689 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaUnnest/array&numMergeBuffers=3
+!set outputformat mysql
+SELECT *
+FROM test_unnest;
++-------------------------+-------+--------+--------------+--------------+------------------+----------------+--------------------+---------+--------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| __time                  | s_int | s_null | a_bool       | a_int        | a_float          | a_str          | a_null             | a_empty | a_mixed                  | a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------+-------+--------+--------------+--------------+------------------+----------------+--------------------+---------+--------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| 2022-01-01 00:00:00.000 |     1 |        | [1, 0, null] | [1, 2, null] | [0.1, 0.2, null] | [S1, S2, null] | [null, null, null] | []      | [true, 1, 0.1, S1, null] | [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| 2022-02-01 00:00:00.000 |     2 |        | [null, 1, 0] | [null, 1, 2] | [null, 0.1, 0.2] | [null, S1, S2] | [null, null, null] | []      | [null, true, 1, 0.1, S1] | [[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"],[[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"],[[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"]]]] |
+| 2022-03-01 00:00:00.000 |       |        | [0, null, 1] | [2, null, 1] | [0.2, null, 0.1] | [S2, null, S1] | [null, null, null] | []      | [S1, null, true, 1, 0.1] | [[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1],[[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1],[[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1]]]] |
++-------------------------+-------+--------+--------------+--------------+------------------+----------------+--------------------+---------+--------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING count(*) IN (3);
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING count(*) IN (3);
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING count(*) IN (3);
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING count(*) IN (3);
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING count(DISTINCT c) IN (0,
+                             1);
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING count(DISTINCT c) IN (0,
+                             1);
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING count(DISTINCT c) IN (2);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING count(DISTINCT c) IN (2);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING count(DISTINCT s_int) IN (2);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING count(DISTINCT s_int) IN (2);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING count(DISTINCT s_int) IN (0,
+                                 1);
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING count(DISTINCT s_int) IN (0,
+                                 1);
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   3 |
+|   6 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   3 |
+|   6 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   3 |
+|   6 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   3 |
+|   6 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING sum(c) IN (3,
+                  6);
++-----+
+| col |
++-----+
+|   3 |
+|   6 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING sum(c) IN (3,
+                  6);
++-----+
+| col |
++-----+
+|   3 |
+|   6 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING sum(c) IN (3);
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING sum(c) IN (3);
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING sum(s_int) IN (3);
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING sum(s_int) IN (3);
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING sum(s_int) IN (3,
+                      6);
++-----+
+| col |
++-----+
+|   3 |
+|   6 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING sum(s_int) IN (3,
+                      6);
++-----+
+| col |
++-----+
+|   3 |
+|   6 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING min(c) IN (1,
+                  2);
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING min(c) IN (1,
+                  2);
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING min(c) IN (1);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING min(c) IN (1);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING min(s_int) IN (1);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING min(s_int) IN (1);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING min(s_int) IN (1,
+                      2);
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING min(s_int) IN (1,
+                      2);
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING max(c) IN (1,
+                  2);
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING max(c) IN (1,
+                  2);
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING max(c) IN (2);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING max(c) IN (2);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING max(s_int) IN (2);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING max(s_int) IN (2);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING max(s_int) IN (1,
+                      2);
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING max(s_int) IN (1,
+                      2);
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(c) AS int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(c) AS int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(s_int) AS int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(s_int) AS int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(c) AS int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(c) AS int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(c) AS int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(c) AS int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(s_int) AS int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(s_int) AS int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(s_int) AS int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(s_int) AS int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(c) AS int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING avg(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(c) AS int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING avg(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(c) AS int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING avg(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(c) AS int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING avg(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(s_int) AS int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING avg(s_int) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(s_int) AS int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING avg(s_int) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(s_int) AS int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING avg(s_int) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(avg(s_int) AS int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING avg(s_int) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING approx_count_distinct(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING approx_count_distinct(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING approx_count_distinct(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING approx_count_distinct(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING approx_count_distinct(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING approx_count_distinct(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING approx_count_distinct(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING approx_count_distinct(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING approx_count_distinct_builtin(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING approx_count_distinct_builtin(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING approx_count_distinct_builtin(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING approx_count_distinct_builtin(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING approx_count_distinct_builtin(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING approx_count_distinct_builtin(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING approx_count_distinct_builtin(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING approx_count_distinct_builtin(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING earliest(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING earliest(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING earliest(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING earliest(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING earliest(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING earliest(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING earliest(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING earliest(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING earliest(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING earliest(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING earliest(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING earliest(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING earliest(s_int, 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING earliest(s_int, 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING earliest(s_int, 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING earliest(s_int, 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING earliest_by(c, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING earliest_by(c, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING earliest_by(c, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING earliest_by(c, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING earliest_by(s_int, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING earliest_by(s_int, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING earliest_by(s_int, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING earliest_by(s_int, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING earliest_by(c, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING earliest_by(c, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING earliest_by(c, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING earliest_by(c, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING earliest_by(s_int, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING earliest_by(s_int, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING earliest_by(s_int, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING earliest_by(s_int, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING latest(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING latest(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING latest(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING latest(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING latest(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING latest(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING latest(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING latest(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING latest(c, 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING latest(c, 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING latest(c, 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING latest(c, 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING latest(s_int, 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING latest(s_int, 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING latest(s_int, 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(s_int, 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING latest(s_int, 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING latest_by(c, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING latest_by(c, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING latest_by(c, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING latest_by(c, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING latest_by(s_int, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING latest_by(s_int, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING latest_by(s_int, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING latest_by(s_int, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING latest_by(c, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING latest_by(c, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING latest_by(c, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING latest_by(c, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING latest_by(s_int, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING latest_by(s_int, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING latest_by(s_int, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(s_int, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING latest_by(s_int, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING any_value(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING any_value(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING any_value(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING any_value(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING any_value(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY c
+   HAVING any_value(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(s_int) AS col
+   FROM test_unnest,
+        unnest(a_int) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING any_value(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE s_int IN (0,
+                   1,
+                   2)
+     OR s_int IS NULL
+   GROUP BY s_int
+   HAVING any_value(s_int) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c col,
+       count(*) cnt,
+       grouping(c) gp
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c col,
+       count(*) cnt,
+       grouping(c) gp
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int col,
+       count(*) cnt,
+       grouping(s_int) gp
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int col,
+       count(*) cnt,
+       grouping(s_int) gp
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c col,
+       count(*) cnt,
+       grouping(c) gp
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+-----+----+
+| col | cnt | gp |
++-----+-----+----+
+|   1 |   3 |  0 |
+|   2 |   3 |  0 |
+|     |   3 |  0 |
++-----+-----+----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c col,
+       count(*) cnt,
+       grouping(c) gp
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+-----+----+
+| col | cnt | gp |
++-----+-----+----+
+|   1 |   3 |  0 |
+|   2 |   3 |  0 |
+|     |   3 |  0 |
++-----+-----+----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c col,
+       count(*) cnt,
+       grouping(c) gp
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C4_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c col,
+       count(*) cnt,
+       grouping(c) gp
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int col,
+       count(*) cnt,
+       grouping(s_int) gp
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C5_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int col,
+       count(*) cnt,
+       grouping(s_int) gp
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int col,
+       count(*) cnt,
+       grouping(s_int) gp
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+-----+----+
+| col | cnt | gp |
++-----+-----+----+
+|   1 |   3 |  0 |
+|   2 |   3 |  0 |
+|     |   3 |  0 |
++-----+-----+----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int col,
+       count(*) cnt,
+       grouping(s_int) gp
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+-----+----+
+| col | cnt | gp |
++-----+-----+----+
+|   1 |   3 |  0 |
+|   2 |   3 |  0 |
+|     |   3 |  0 |
++-----+-----+----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c col,
+       count(*) cnt,
+       grouping(c) gp
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING grouping(c) IS NOT NULL;
++-----+-----+----+
+| col | cnt | gp |
++-----+-----+----+
+|   1 |   3 |  0 |
+|   2 |   3 |  0 |
+|     |   3 |  0 |
++-----+-----+----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c col,
+       count(*) cnt,
+       grouping(c) gp
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING grouping(c) IS NOT NULL;
++-----+-----+----+
+| col | cnt | gp |
++-----+-----+----+
+|   1 |   3 |  0 |
+|   2 |   3 |  0 |
+|     |   3 |  0 |
++-----+-----+----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c col,
+       count(*) cnt,
+       grouping(c) gp
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING grouping(c) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C8_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c col,
+       count(*) cnt,
+       grouping(c) gp
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING grouping(c) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int col,
+       count(*) cnt,
+       grouping(s_int) gp
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING grouping(s_int) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C9_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int col,
+       count(*) cnt,
+       grouping(s_int) gp
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING grouping(s_int) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int col,
+       count(*) cnt,
+       grouping(s_int) gp
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING grouping(s_int) IS NOT NULL;
++-----+-----+----+
+| col | cnt | gp |
++-----+-----+----+
+|   1 |   3 |  0 |
+|   2 |   3 |  0 |
+|     |   3 |  0 |
++-----+-----+----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT s_int col,
+       count(*) cnt,
+       grouping(s_int) gp
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING grouping(s_int) IS NOT NULL;
++-----+-----+----+
+| col | cnt | gp |
++-----+-----+----+
+|   1 |   3 |  0 |
+|   2 |   3 |  0 |
+|     |   3 |  0 |
++-----+-----+----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++--------------------------------------+
+| col                                  |
++--------------------------------------+
+| [1, 2, null, null, 1, 2, 2, null, 1] |
++--------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++--------------------------------------+
+| col                                  |
++--------------------------------------+
+| [1, 2, null, null, 1, 2, 2, null, 1] |
++--------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++--------------------------------------+
+| col                                  |
++--------------------------------------+
+| [1, 1, 1, 2, 2, 2, null, null, null] |
++--------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++--------------------------------------+
+| col                                  |
++--------------------------------------+
+| [1, 1, 1, 2, 2, 2, null, null, null] |
++--------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++--------------------+
+| col                |
++--------------------+
+| [1, 1, 1]          |
+| [2, 2, 2]          |
+| [null, null, null] |
++--------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++--------------------+
+| col                |
++--------------------+
+| [1, 1, 1]          |
+| [2, 2, 2]          |
+| [null, null, null] |
++--------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [2, null, 1] |
+| [null, 1, 2] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [2, null, 1] |
+| [null, 1, 2] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++--------------------+
+| col                |
++--------------------+
+| [1, 1, 1]          |
+| [2, 2, 2]          |
+| [null, null, null] |
++--------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++--------------------+
+| col                |
++--------------------+
+| [1, 1, 1]          |
+| [2, 2, 2]          |
+| [null, null, null] |
++--------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING array_agg(c) IS NOT NULL;
++--------------------+
+| col                |
++--------------------+
+| [1, 1, 1]          |
+| [2, 2, 2]          |
+| [null, null, null] |
++--------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING array_agg(c) IS NOT NULL;
++--------------------+
+| col                |
++--------------------+
+| [1, 1, 1]          |
+| [2, 2, 2]          |
+| [null, null, null] |
++--------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING array_agg(c) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [2, null, 1] |
+| [null, 1, 2] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING array_agg(c) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [2, null, 1] |
+| [null, 1, 2] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING array_agg(s_int) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING array_agg(s_int) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING array_agg(s_int) IS NOT NULL;
++--------------------+
+| col                |
++--------------------+
+| [1, 1, 1]          |
+| [2, 2, 2]          |
+| [null, null, null] |
++--------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING array_agg(s_int) IS NOT NULL;
++--------------------+
+| col                |
++--------------------+
+| [1, 1, 1]          |
+| [2, 2, 2]          |
+| [null, null, null] |
++--------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++--------------+
+| col          |
++--------------+
+| [null, 1, 2] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++--------------+
+| col          |
++--------------+
+| [null, 1, 2] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++--------------+
+| col          |
++--------------+
+| [null, 1, 2] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++--------------+
+| col          |
++--------------+
+| [null, 1, 2] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++--------+
+| col    |
++--------+
+| [1]    |
+| [2]    |
+| [null] |
++--------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++--------+
+| col    |
++--------+
+| [1]    |
+| [2]    |
+| [null] |
++--------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++--------------+
+| col          |
++--------------+
+| [null, 1, 2] |
+| [null, 1, 2] |
+| [null, 1, 2] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++--------------+
+| col          |
++--------------+
+| [null, 1, 2] |
+| [null, 1, 2] |
+| [null, 1, 2] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++--------------+
+| col          |
++--------------+
+| [null, 1, 2] |
+| [null, 1, 2] |
+| [null, 1, 2] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++--------------+
+| col          |
++--------------+
+| [null, 1, 2] |
+| [null, 1, 2] |
+| [null, 1, 2] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++--------+
+| col    |
++--------+
+| [1]    |
+| [2]    |
+| [null] |
++--------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++--------+
+| col    |
++--------+
+| [1]    |
+| [2]    |
+| [null] |
++--------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING array_agg(DISTINCT c) IS NOT NULL;
++--------+
+| col    |
++--------+
+| [1]    |
+| [2]    |
+| [null] |
++--------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING array_agg(DISTINCT c) IS NOT NULL;
++--------+
+| col    |
++--------+
+| [1]    |
+| [2]    |
+| [null] |
++--------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING array_agg(DISTINCT c) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [null, 1, 2] |
+| [null, 1, 2] |
+| [null, 1, 2] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING array_agg(DISTINCT c) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [null, 1, 2] |
+| [null, 1, 2] |
+| [null, 1, 2] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING array_agg(DISTINCT s_int) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [null, 1, 2] |
+| [null, 1, 2] |
+| [null, 1, 2] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING array_agg(DISTINCT s_int) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [null, 1, 2] |
+| [null, 1, 2] |
+| [null, 1, 2] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING array_agg(DISTINCT s_int) IS NOT NULL;
++--------+
+| col    |
++--------+
+| [1]    |
+| [2]    |
+| [null] |
++--------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING array_agg(DISTINCT s_int) IS NOT NULL;
++--------+
+| col    |
++--------+
+| [1]    |
+| [2]    |
+| [null] |
++--------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C3_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C4_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C5_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C6_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING array_concat_agg(c) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C7_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING array_concat_agg(c) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING array_concat_agg(c) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C8_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING array_concat_agg(c) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING array_concat_agg(s_int) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C9_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING array_concat_agg(s_int) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING array_concat_agg(s_int) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C10_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING array_concat_agg(s_int) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C3_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C4_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C5_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C6_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING array_concat_agg(DISTINCT c) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C7_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING array_concat_agg(DISTINCT c) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING array_concat_agg(DISTINCT c) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C8_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING array_concat_agg(DISTINCT c) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING array_concat_agg(DISTINCT s_int) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C9_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING array_concat_agg(DISTINCT s_int) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING array_concat_agg(DISTINCT s_int) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C10_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING array_concat_agg(DISTINCT s_int) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-------------+
+| col         |
++-------------+
+| 1|2|1|2|2|1 |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-------------+
+| col         |
++-------------+
+| 1|2|1|2|2|1 |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(s_int, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-------------+
+| col         |
++-------------+
+| 1|1|1|2|2|2 |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(s_int, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-------------+
+| col         |
++-------------+
+| 1|1|1|2|2|2 |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-------+
+| col   |
++-------+
+| 1|1|1 |
+| 2|2|2 |
+|       |
++-------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-------+
+| col   |
++-------+
+| 1|1|1 |
+| 2|2|2 |
+|       |
++-------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+| 1|2 |
+| 1|2 |
+| 2|1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+| 1|2 |
+| 1|2 |
+| 2|1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(s_int, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+| 1|2 |
+| 1|2 |
+| 1|2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(s_int, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+| 1|2 |
+| 1|2 |
+| 1|2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(s_int, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-------+
+| col   |
++-------+
+| 1|1|1 |
+| 2|2|2 |
+|       |
++-------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(s_int, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-------+
+| col   |
++-------+
+| 1|1|1 |
+| 2|2|2 |
+|       |
++-------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING string_agg(c, '|') IS NOT NULL;
++-------+
+| col   |
++-------+
+| 1|1|1 |
+| 2|2|2 |
++-------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING string_agg(c, '|') IS NOT NULL;
++-------+
+| col   |
++-------+
+| 1|1|1 |
+| 2|2|2 |
++-------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING string_agg(c, '|') IS NOT NULL;
++-----+
+| col |
++-----+
+| 1|2 |
+| 1|2 |
+| 2|1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING string_agg(c, '|') IS NOT NULL;
++-----+
+| col |
++-----+
+| 1|2 |
+| 1|2 |
+| 2|1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(s_int, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING string_agg(s_int, '|') IS NOT NULL;
++-----+
+| col |
++-----+
+| 1|2 |
+| 1|2 |
+| 1|2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(s_int, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING string_agg(s_int, '|') IS NOT NULL;
++-----+
+| col |
++-----+
+| 1|2 |
+| 1|2 |
+| 1|2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(s_int, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING string_agg(s_int, '|') IS NOT NULL;
++-------+
+| col   |
++-------+
+| 1|1|1 |
+| 2|2|2 |
++-------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(s_int, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING string_agg(s_int, '|') IS NOT NULL;
++-------+
+| col   |
++-------+
+| 1|1|1 |
+| 2|2|2 |
++-------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+| 1|2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+| 1|2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT s_int, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+| 1|2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT s_int, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+| 1|2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+| 1   |
+| 2   |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+| 1   |
+| 2   |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+| 1|2 |
+| 1|2 |
+| 1|2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+| 1|2 |
+| 1|2 |
+| 1|2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT s_int, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+| 1|2 |
+| 1|2 |
+| 1|2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT s_int, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+| 1|2 |
+| 1|2 |
+| 1|2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT s_int, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+| 1   |
+| 2   |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT s_int, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+| 1   |
+| 2   |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING string_agg(DISTINCT c, '|') IS NOT NULL;
++-----+
+| col |
++-----+
+| 1   |
+| 2   |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING string_agg(DISTINCT c, '|') IS NOT NULL;
++-----+
+| col |
++-----+
+| 1   |
+| 2   |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING string_agg(DISTINCT c, '|') IS NOT NULL;
++-----+
+| col |
++-----+
+| 1|2 |
+| 1|2 |
+| 1|2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING string_agg(DISTINCT c, '|') IS NOT NULL;
++-----+
+| col |
++-----+
+| 1|2 |
+| 1|2 |
+| 1|2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT s_int, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING string_agg(DISTINCT s_int, '|') IS NOT NULL;
++-----+
+| col |
++-----+
+| 1|2 |
+| 1|2 |
+| 1|2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT s_int, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING string_agg(DISTINCT s_int, '|') IS NOT NULL;
++-----+
+| col |
++-----+
+| 1|2 |
+| 1|2 |
+| 1|2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT s_int, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING string_agg(DISTINCT s_int, '|') IS NOT NULL;
++-----+
+| col |
++-----+
+| 1   |
+| 2   |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT s_int, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING string_agg(DISTINCT s_int, '|') IS NOT NULL;
++-----+
+| col |
++-----+
+| 1   |
+| 2   |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING bit_and(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING bit_and(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING bit_and(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING bit_and(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING bit_and(s_int) IS NOT NULL;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING bit_and(s_int) IS NOT NULL;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING bit_and(s_int) IS NOT NULL;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING bit_and(s_int) IS NOT NULL;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING bit_or(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING bit_or(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING bit_or(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING bit_or(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING bit_or(s_int) IS NOT NULL;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING bit_or(s_int) IS NOT NULL;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING bit_or(s_int) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING bit_or(s_int) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL;
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING bit_xor(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING bit_xor(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING bit_xor(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING bit_xor(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING bit_xor(s_int) IS NOT NULL;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY c
+HAVING bit_xor(s_int) IS NOT NULL;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING bit_xor(s_int) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE s_int IN (0,
+                1,
+                2)
+  OR s_int IS NULL
+GROUP BY s_int
+HAVING bit_xor(s_int) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[1,
+             2,
+             3] AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array[1,
+             2,
+             3]<array[99999]);
++-----------+
+| col       |
++-----------+
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[1,
+             2,
+             3] AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array[1,
+             2,
+             3]<array[99999]);
++-----------+
+| col       |
++-----------+
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[c,
+             c,
+             3] AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array[c,
+             c,
+             3]<array[99999]);
++-----------------+
+| col             |
++-----------------+
+| [1, 1, 3]       |
+| [1, 1, 3]       |
+| [1, 1, 3]       |
+| [2, 2, 3]       |
+| [2, 2, 3]       |
+| [2, 2, 3]       |
+| [null, null, 3] |
+| [null, null, 3] |
+| [null, null, 3] |
++-----------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[c,
+             c,
+             3] AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array[c,
+             c,
+             3]<array[99999]);
++-----------------+
+| col             |
++-----------------+
+| [1, 1, 3]       |
+| [1, 1, 3]       |
+| [1, 1, 3]       |
+| [2, 2, 3]       |
+| [2, 2, 3]       |
+| [2, 2, 3]       |
+| [null, null, 3] |
+| [null, null, 3] |
+| [null, null, 3] |
++-----------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[c,
+             s_int,
+             3] AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array[c,
+             s_int,
+             3]<array[99999]);
++-----------------+
+| col             |
++-----------------+
+| [1, 1, 3]       |
+| [1, 2, 3]       |
+| [1, null, 3]    |
+| [2, 1, 3]       |
+| [2, 2, 3]       |
+| [2, null, 3]    |
+| [null, 1, 3]    |
+| [null, 2, 3]    |
+| [null, null, 3] |
++-----------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[c,
+             s_int,
+             3] AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array[c,
+             s_int,
+             3]<array[99999]);
++-----------------+
+| col             |
++-----------------+
+| [1, 1, 3]       |
+| [1, 2, 3]       |
+| [1, null, 3]    |
+| [2, 1, 3]       |
+| [2, 2, 3]       |
+| [2, null, 3]    |
+| [null, 1, 3]    |
+| [null, 2, 3]    |
+| [null, null, 3] |
++-----------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[s_int,
+             c,
+             3] AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array[s_int,
+             c,
+             3]<array[99999]);
++-----------------+
+| col             |
++-----------------+
+| [1, 1, 3]       |
+| [1, 2, 3]       |
+| [1, null, 3]    |
+| [2, 1, 3]       |
+| [2, 2, 3]       |
+| [2, null, 3]    |
+| [null, 1, 3]    |
+| [null, 2, 3]    |
+| [null, null, 3] |
++-----------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[s_int,
+             c,
+             3] AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array[s_int,
+             c,
+             3]<array[99999]);
++-----------------+
+| col             |
++-----------------+
+| [1, 1, 3]       |
+| [1, 2, 3]       |
+| [1, null, 3]    |
+| [2, 1, 3]       |
+| [2, 2, 3]       |
+| [2, null, 3]    |
+| [null, 1, 3]    |
+| [null, 2, 3]    |
+| [null, null, 3] |
++-----------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[s_int,
+             s_int,
+             3] AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array[s_int,
+             s_int,
+             3]<array[99999]);
++-----------------+
+| col             |
++-----------------+
+| [1, 1, 3]       |
+| [1, 1, 3]       |
+| [1, 1, 3]       |
+| [2, 2, 3]       |
+| [2, 2, 3]       |
+| [2, 2, 3]       |
+| [null, null, 3] |
+| [null, null, 3] |
+| [null, null, 3] |
++-----------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[s_int,
+             s_int,
+             3] AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array[s_int,
+             s_int,
+             3]<array[99999]);
++-----------------+
+| col             |
++-----------------+
+| [1, 1, 3]       |
+| [1, 1, 3]       |
+| [1, 1, 3]       |
+| [2, 2, 3]       |
+| [2, 2, 3]       |
+| [2, 2, 3]       |
+| [null, null, 3] |
+| [null, null, 3] |
+| [null, null, 3] |
++-----------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_length(c)<99999
+       OR array_length(c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_length(c)<99999
+       OR array_length(c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_length(s_int)<99999
+       OR array_length(s_int) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_length(s_int)<99999
+       OR array_length(s_int) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_length(array[c, c, 3])<99999
+       OR array_length(array[c, c, 3]) IS NULL);
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_length(array[c, c, 3])<99999
+       OR array_length(array[c, c, 3]) IS NULL);
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_length(array[s_int, c, 3])<99999
+       OR array_length(array[s_int, c, 3]) IS NULL);
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_length(array[s_int, c, 3])<99999
+       OR array_length(array[s_int, c, 3]) IS NULL);
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_length(array[c, s_int, 3])<99999
+       OR array_length(array[c, s_int, 3]) IS NULL);
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_length(array[c, s_int, 3])<99999
+       OR array_length(array[c, s_int, 3]) IS NULL);
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_length(array[s_int, s_int, 3])<99999
+       OR array_length(array[s_int, s_int, 3]) IS NULL);
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_length(array[s_int, s_int, 3])<99999
+       OR array_length(array[s_int, s_int, 3]) IS NULL);
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(c, 0) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset(c, 0)<99999
+       OR array_offset(c, 0) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(c, 0) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset(c, 0)<99999
+       OR array_offset(c, 0) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(s_int, 0) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset(s_int, 0)<99999
+       OR array_offset(s_int, 0) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(s_int, 0) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset(s_int, 0)<99999
+       OR array_offset(s_int, 0) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array[c, c, 3],0) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset(array[c, c, 3],0)<99999
+       OR array_offset(array[c, c, 3],0) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array[c, c, 3],0) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset(array[c, c, 3],0)<99999
+       OR array_offset(array[c, c, 3],0) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array[s_int, c, 3],0) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset(array[s_int, c, 3],0)<99999
+       OR array_offset(array[s_int, c, 3],0) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array[s_int, c, 3],0) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset(array[s_int, c, 3],0)<99999
+       OR array_offset(array[s_int, c, 3],0) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array[c, s_int, 3],0) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset(array[c, s_int, 3],0)<99999
+       OR array_offset(array[c, s_int, 3],0) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array[c, s_int, 3],0) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset(array[c, s_int, 3],0)<99999
+       OR array_offset(array[c, s_int, 3],0) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array[s_int, s_int, 3],0) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset(array[s_int, s_int, 3],0)<99999
+       OR array_offset(array[s_int, s_int, 3],0) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array[s_int, s_int, 3],0) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset(array[s_int, s_int, 3],0)<99999
+       OR array_offset(array[s_int, s_int, 3],0) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(c, 1) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal(c, 1)<99999
+       OR array_ordinal(c, 1) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(c, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal(c, 1)<99999
+       OR array_ordinal(c, 1) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(s_int, 1) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal(s_int, 1)<99999
+       OR array_ordinal(s_int, 1) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(s_int, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal(s_int, 1)<99999
+       OR array_ordinal(s_int, 1) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array[c, c, 3],1) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal(array[c, c, 3],1)<99999
+       OR array_ordinal(array[c, c, 3],1) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array[c, c, 3],1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal(array[c, c, 3],1)<99999
+       OR array_ordinal(array[c, c, 3],1) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array[s_int, c, 3],1) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal(array[s_int, c, 3],1)<99999
+       OR array_ordinal(array[s_int, c, 3],1) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array[s_int, c, 3],1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal(array[s_int, c, 3],1)<99999
+       OR array_ordinal(array[s_int, c, 3],1) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array[c, s_int, 3],1) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal(array[c, s_int, 3],1)<99999
+       OR array_ordinal(array[c, s_int, 3],1) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array[c, s_int, 3],1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal(array[c, s_int, 3],1)<99999
+       OR array_ordinal(array[c, s_int, 3],1) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array[s_int, s_int, 3],1) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal(array[s_int, s_int, 3],1)<99999
+       OR array_ordinal(array[s_int, s_int, 3],1) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array[s_int, s_int, 3],1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal(array[s_int, s_int, 3],1)<99999
+       OR array_ordinal(array[s_int, s_int, 3],1) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(c,array[1, 2, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(c,array[1, 2, 3]) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(c,array[1, 2, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(c,array[1, 2, 3]) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(s_int,array[1, 2, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(s_int,array[1, 2, 3]) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(s_int,array[1, 2, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(s_int,array[1, 2, 3]) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[c, c, 3],c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[c, c, 3],c) IS NOT NULL);
+Invalid expression
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C3_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[c, c, 3],c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[c, c, 3],c) IS NOT NULL);
+Invalid expression
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[s_int, c, 3],s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[s_int, c, 3],s_int) IS NOT NULL);
+Invalid expression
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C4_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[s_int, c, 3],s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[s_int, c, 3],s_int) IS NOT NULL);
+Invalid expression
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[c, s_int, 3],c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[c, s_int, 3],c) IS NOT NULL);
+Invalid expression
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C5_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[c, s_int, 3],c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[c, s_int, 3],c) IS NOT NULL);
+Invalid expression
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[s_int, s_int, 3],s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[s_int, s_int, 3],s_int) IS NOT NULL);
+Invalid expression
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C6_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[s_int, s_int, 3],s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[s_int, s_int, 3],s_int) IS NOT NULL);
+Invalid expression
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[c, c, 3],1) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[c, c, 3],1) IS NOT NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[c, c, 3],1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[c, c, 3],1) IS NOT NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[s_int, c, 3],1) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[s_int, c, 3],1) IS NOT NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[s_int, c, 3],1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[s_int, c, 3],1) IS NOT NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[c, s_int, 3],1) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[c, s_int, 3],1) IS NOT NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[c, s_int, 3],1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[c, s_int, 3],1) IS NOT NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[s_int, s_int, 3],1) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[s_int, s_int, 3],1) IS NOT NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[s_int, s_int, 3],1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[s_int, s_int, 3],1) IS NOT NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[c, c, 3],array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[c, c, 3],array[c, c, 3]) IS NOT NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C11_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[c, c, 3],array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[c, c, 3],array[c, c, 3]) IS NOT NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[s_int, c, 3],array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[s_int, c, 3],array[s_int, c, 3]) IS NOT NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C12_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[s_int, c, 3],array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[s_int, c, 3],array[s_int, c, 3]) IS NOT NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[c, s_int, 3],array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[c, s_int, 3],array[c, s_int, 3]) IS NOT NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C13_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[c, s_int, 3],array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[c, s_int, 3],array[c, s_int, 3]) IS NOT NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[s_int, s_int, 3],array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[s_int, s_int, 3],array[s_int, s_int, 3]) IS NOT NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C14_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array[s_int, s_int, 3],array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_contains(array[s_int, s_int, 3],array[s_int, s_int, 3]) IS NOT NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(c, s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(c, s_int) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(c, s_int) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(s_int, c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(s_int, c) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(s_int, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(s_int, c) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array[c, c, 3],c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(array[c, c, 3],c) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C3_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array[c, c, 3],c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(array[c, c, 3],c) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array[s_int, c, 3],s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(array[s_int, c, 3],s_int) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C4_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array[s_int, c, 3],s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(array[s_int, c, 3],s_int) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array[c, s_int, 3],c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(array[c, s_int, 3],c) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C5_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array[c, s_int, 3],c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(array[c, s_int, 3],c) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array[s_int, s_int, 3],s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(array[s_int, s_int, 3],s_int) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C6_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array[s_int, s_int, 3],s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(array[s_int, s_int, 3],s_int) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(c,array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(c,array[c, c, 3]) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C7_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(c,array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(c,array[c, c, 3]) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(s_int,array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(s_int,array[s_int, c, 3]) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C8_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(s_int,array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(s_int,array[s_int, c, 3]) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(c,array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(c,array[c, s_int, 3]) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C9_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(c,array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(c,array[c, s_int, 3]) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(s_int,array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(s_int,array[s_int, s_int, 3]) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C10_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(s_int,array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(s_int,array[s_int, s_int, 3]) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array[c, c, 3],array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(array[c, c, 3],array[c, c, 3]) IS NOT NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C11_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array[c, c, 3],array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(array[c, c, 3],array[c, c, 3]) IS NOT NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array[s_int, c, 3],array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(array[s_int, c, 3],array[s_int, c, 3]) IS NOT NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C12_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array[s_int, c, 3],array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(array[s_int, c, 3],array[s_int, c, 3]) IS NOT NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array[c, s_int, 3],array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(array[c, s_int, 3],array[c, s_int, 3]) IS NOT NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C13_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array[c, s_int, 3],array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(array[c, s_int, 3],array[c, s_int, 3]) IS NOT NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array[s_int, s_int, 3],array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(array[s_int, s_int, 3],array[s_int, s_int, 3]) IS NOT NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C14_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array[s_int, s_int, 3],array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_overlap(array[s_int, s_int, 3],array[s_int, s_int, 3]) IS NOT NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(c, s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(c, s_int)<99999
+       OR array_offset_of(c, s_int) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(c, s_int)<99999
+       OR array_offset_of(c, s_int) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(s_int, c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(s_int, c)<99999
+       OR array_offset_of(s_int, c) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(s_int, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(s_int, c)<99999
+       OR array_offset_of(s_int, c) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array[c, c, 3],c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(array[c, c, 3],c)<99999
+       OR array_offset_of(array[c, c, 3],c) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array[c, c, 3],c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(array[c, c, 3],c)<99999
+       OR array_offset_of(array[c, c, 3],c) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array[s_int, c, 3],s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(array[s_int, c, 3],s_int)<99999
+       OR array_offset_of(array[s_int, c, 3],s_int) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array[s_int, c, 3],s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(array[s_int, c, 3],s_int)<99999
+       OR array_offset_of(array[s_int, c, 3],s_int) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array[c, s_int, 3],c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(array[c, s_int, 3],c)<99999
+       OR array_offset_of(array[c, s_int, 3],c) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array[c, s_int, 3],c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(array[c, s_int, 3],c)<99999
+       OR array_offset_of(array[c, s_int, 3],c) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array[s_int, s_int, 3],s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(array[s_int, s_int, 3],s_int)<99999
+       OR array_offset_of(array[s_int, s_int, 3],s_int) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array[s_int, s_int, 3],s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(array[s_int, s_int, 3],s_int)<99999
+       OR array_offset_of(array[s_int, s_int, 3],s_int) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(c,array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(c,array[c, c, 3])<99999
+       OR array_offset_of(c,array[c, c, 3]) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C7_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(c,array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(c,array[c, c, 3])<99999
+       OR array_offset_of(c,array[c, c, 3]) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(s_int,array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(s_int,array[s_int, c, 3])<99999
+       OR array_offset_of(s_int,array[s_int, c, 3]) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C8_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(s_int,array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(s_int,array[s_int, c, 3])<99999
+       OR array_offset_of(s_int,array[s_int, c, 3]) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(c,array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(c,array[c, s_int, 3])<99999
+       OR array_offset_of(c,array[c, s_int, 3]) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C9_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(c,array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(c,array[c, s_int, 3])<99999
+       OR array_offset_of(c,array[c, s_int, 3]) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(s_int,array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(s_int,array[s_int, s_int, 3])<99999
+       OR array_offset_of(s_int,array[s_int, s_int, 3]) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C10_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(s_int,array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(s_int,array[s_int, s_int, 3])<99999
+       OR array_offset_of(s_int,array[s_int, s_int, 3]) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array[c, c, 3],array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(array[c, c, 3],array[c, c, 3])<99999
+       OR array_offset_of(array[c, c, 3],array[c, c, 3]) IS NULL);
+second argument must be
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C11_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array[c, c, 3],array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(array[c, c, 3],array[c, c, 3])<99999
+       OR array_offset_of(array[c, c, 3],array[c, c, 3]) IS NULL);
+second argument must be
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array[s_int, c, 3],array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(array[s_int, c, 3],array[s_int, c, 3])<99999
+       OR array_offset_of(array[s_int, c, 3],array[s_int, c, 3]) IS NULL);
+second argument must be
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C12_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array[s_int, c, 3],array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(array[s_int, c, 3],array[s_int, c, 3])<99999
+       OR array_offset_of(array[s_int, c, 3],array[s_int, c, 3]) IS NULL);
+second argument must be
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array[c, s_int, 3],array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(array[c, s_int, 3],array[c, s_int, 3])<99999
+       OR array_offset_of(array[c, s_int, 3],array[c, s_int, 3]) IS NULL);
+second argument must be
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C13_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array[c, s_int, 3],array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(array[c, s_int, 3],array[c, s_int, 3])<99999
+       OR array_offset_of(array[c, s_int, 3],array[c, s_int, 3]) IS NULL);
+second argument must be
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array[s_int, s_int, 3],array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(array[s_int, s_int, 3],array[s_int, s_int, 3])<99999
+       OR array_offset_of(array[s_int, s_int, 3],array[s_int, s_int, 3]) IS NULL);
+second argument must be
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C14_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array[s_int, s_int, 3],array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_offset_of(array[s_int, s_int, 3],array[s_int, s_int, 3])<99999
+       OR array_offset_of(array[s_int, s_int, 3],array[s_int, s_int, 3]) IS NULL);
+second argument must be
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(c, s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(c, s_int)<99999
+       OR array_ordinal_of(c, s_int) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(c, s_int)<99999
+       OR array_ordinal_of(c, s_int) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(s_int, c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(s_int, c)<99999
+       OR array_ordinal_of(s_int, c) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(s_int, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(s_int, c)<99999
+       OR array_ordinal_of(s_int, c) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array[c, c, 3],c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(array[c, c, 3],c)<99999
+       OR array_ordinal_of(array[c, c, 3],c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array[c, c, 3],c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(array[c, c, 3],c)<99999
+       OR array_ordinal_of(array[c, c, 3],c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array[s_int, c, 3],s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(array[s_int, c, 3],s_int)<99999
+       OR array_ordinal_of(array[s_int, c, 3],s_int) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array[s_int, c, 3],s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(array[s_int, c, 3],s_int)<99999
+       OR array_ordinal_of(array[s_int, c, 3],s_int) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array[c, s_int, 3],c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(array[c, s_int, 3],c)<99999
+       OR array_ordinal_of(array[c, s_int, 3],c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array[c, s_int, 3],c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(array[c, s_int, 3],c)<99999
+       OR array_ordinal_of(array[c, s_int, 3],c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array[s_int, s_int, 3],s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(array[s_int, s_int, 3],s_int)<99999
+       OR array_ordinal_of(array[s_int, s_int, 3],s_int) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array[s_int, s_int, 3],s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(array[s_int, s_int, 3],s_int)<99999
+       OR array_ordinal_of(array[s_int, s_int, 3],s_int) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(c,array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(c,array[c, c, 3])<99999
+       OR array_ordinal_of(c,array[c, c, 3]) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C7_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(c,array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(c,array[c, c, 3])<99999
+       OR array_ordinal_of(c,array[c, c, 3]) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(s_int,array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(s_int,array[s_int, c, 3])<99999
+       OR array_ordinal_of(s_int,array[s_int, c, 3]) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C8_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(s_int,array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(s_int,array[s_int, c, 3])<99999
+       OR array_ordinal_of(s_int,array[s_int, c, 3]) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(c,array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(c,array[c, s_int, 3])<99999
+       OR array_ordinal_of(c,array[c, s_int, 3]) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C9_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(c,array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(c,array[c, s_int, 3])<99999
+       OR array_ordinal_of(c,array[c, s_int, 3]) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(s_int,array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(s_int,array[s_int, s_int, 3])<99999
+       OR array_ordinal_of(s_int,array[s_int, s_int, 3]) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C10_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(s_int,array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(s_int,array[s_int, s_int, 3])<99999
+       OR array_ordinal_of(s_int,array[s_int, s_int, 3]) IS NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array[c, c, 3],array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(array[c, c, 3],array[c, c, 3])<99999
+       OR array_ordinal_of(array[c, c, 3],array[c, c, 3]) IS NULL);
+second argument must be
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C11_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array[c, c, 3],array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(array[c, c, 3],array[c, c, 3])<99999
+       OR array_ordinal_of(array[c, c, 3],array[c, c, 3]) IS NULL);
+second argument must be
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array[s_int, c, 3],array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(array[s_int, c, 3],array[s_int, c, 3])<99999
+       OR array_ordinal_of(array[s_int, c, 3],array[s_int, c, 3]) IS NULL);
+second argument must be
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C12_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array[s_int, c, 3],array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(array[s_int, c, 3],array[s_int, c, 3])<99999
+       OR array_ordinal_of(array[s_int, c, 3],array[s_int, c, 3]) IS NULL);
+second argument must be
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array[c, s_int, 3],array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(array[c, s_int, 3],array[c, s_int, 3])<99999
+       OR array_ordinal_of(array[c, s_int, 3],array[c, s_int, 3]) IS NULL);
+second argument must be
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C13_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array[c, s_int, 3],array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(array[c, s_int, 3],array[c, s_int, 3])<99999
+       OR array_ordinal_of(array[c, s_int, 3],array[c, s_int, 3]) IS NULL);
+second argument must be
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array[s_int, s_int, 3],array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(array[s_int, s_int, 3],array[s_int, s_int, 3])<99999
+       OR array_ordinal_of(array[s_int, s_int, 3],array[s_int, s_int, 3]) IS NULL);
+second argument must be
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C14_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array[s_int, s_int, 3],array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_ordinal_of(array[s_int, s_int, 3],array[s_int, s_int, 3])<99999
+       OR array_ordinal_of(array[s_int, s_int, 3],array[s_int, s_int, 3]) IS NULL);
+second argument must be
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(c, s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(c, s_int)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(c, s_int)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(s_int, c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(s_int, c)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(s_int, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(s_int, c)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(array[c, c, 3],c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(array[c, c, 3],c)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C3_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(array[c, c, 3],c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(array[c, c, 3],c)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(array[s_int, c, 3],s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(array[s_int, c, 3],s_int)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C4_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(array[s_int, c, 3],s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(array[s_int, c, 3],s_int)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(array[c, s_int, 3],c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(array[c, s_int, 3],c)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C5_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(array[c, s_int, 3],c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(array[c, s_int, 3],c)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(array[s_int, s_int, 3],s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(array[s_int, s_int, 3],s_int)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C6_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(array[s_int, s_int, 3],s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(array[s_int, s_int, 3],s_int)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(c,array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(c,array[c, c, 3])<ARRAY[99999]);
++-----------------------+
+| col                   |
++-----------------------+
+| [1, 1, 1, 3]          |
+| [1, 1, 1, 3]          |
+| [1, 1, 1, 3]          |
+| [2, 2, 2, 3]          |
+| [2, 2, 2, 3]          |
+| [2, 2, 2, 3]          |
+| [null, null, null, 3] |
+| [null, null, null, 3] |
+| [null, null, null, 3] |
++-----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C7_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(c,array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(c,array[c, c, 3])<ARRAY[99999]);
++-----------------------+
+| col                   |
++-----------------------+
+| [1, 1, 1, 3]          |
+| [1, 1, 1, 3]          |
+| [1, 1, 1, 3]          |
+| [2, 2, 2, 3]          |
+| [2, 2, 2, 3]          |
+| [2, 2, 2, 3]          |
+| [null, null, null, 3] |
+| [null, null, null, 3] |
+| [null, null, null, 3] |
++-----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(s_int,array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(s_int,array[s_int, c, 3])<ARRAY[99999]);
++-----------------------+
+| col                   |
++-----------------------+
+| [1, 1, 1, 3]          |
+| [1, 1, 2, 3]          |
+| [1, 1, null, 3]       |
+| [2, 2, 1, 3]          |
+| [2, 2, 2, 3]          |
+| [2, 2, null, 3]       |
+| [null, null, 1, 3]    |
+| [null, null, 2, 3]    |
+| [null, null, null, 3] |
++-----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C8_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(s_int,array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(s_int,array[s_int, c, 3])<ARRAY[99999]);
++-----------------------+
+| col                   |
++-----------------------+
+| [1, 1, 1, 3]          |
+| [1, 1, 2, 3]          |
+| [1, 1, null, 3]       |
+| [2, 2, 1, 3]          |
+| [2, 2, 2, 3]          |
+| [2, 2, null, 3]       |
+| [null, null, 1, 3]    |
+| [null, null, 2, 3]    |
+| [null, null, null, 3] |
++-----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(c,array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(c,array[c, s_int, 3])<ARRAY[99999]);
++-----------------------+
+| col                   |
++-----------------------+
+| [1, 1, 1, 3]          |
+| [1, 1, 2, 3]          |
+| [1, 1, null, 3]       |
+| [2, 2, 1, 3]          |
+| [2, 2, 2, 3]          |
+| [2, 2, null, 3]       |
+| [null, null, 1, 3]    |
+| [null, null, 2, 3]    |
+| [null, null, null, 3] |
++-----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C9_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(c,array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(c,array[c, s_int, 3])<ARRAY[99999]);
++-----------------------+
+| col                   |
++-----------------------+
+| [1, 1, 1, 3]          |
+| [1, 1, 2, 3]          |
+| [1, 1, null, 3]       |
+| [2, 2, 1, 3]          |
+| [2, 2, 2, 3]          |
+| [2, 2, null, 3]       |
+| [null, null, 1, 3]    |
+| [null, null, 2, 3]    |
+| [null, null, null, 3] |
++-----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(s_int,array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(s_int,array[s_int, s_int, 3])<ARRAY[99999]);
++-----------------------+
+| col                   |
++-----------------------+
+| [1, 1, 1, 3]          |
+| [1, 1, 1, 3]          |
+| [1, 1, 1, 3]          |
+| [2, 2, 2, 3]          |
+| [2, 2, 2, 3]          |
+| [2, 2, 2, 3]          |
+| [null, null, null, 3] |
+| [null, null, null, 3] |
+| [null, null, null, 3] |
++-----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C10_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(s_int,array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(s_int,array[s_int, s_int, 3])<ARRAY[99999]);
++-----------------------+
+| col                   |
++-----------------------+
+| [1, 1, 1, 3]          |
+| [1, 1, 1, 3]          |
+| [1, 1, 1, 3]          |
+| [2, 2, 2, 3]          |
+| [2, 2, 2, 3]          |
+| [2, 2, 2, 3]          |
+| [null, null, null, 3] |
+| [null, null, null, 3] |
+| [null, null, null, 3] |
++-----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(array[c, c, 3],array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(array[c, c, 3],array[c, c, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C11_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(array[c, c, 3],array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(array[c, c, 3],array[c, c, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(array[s_int, c, 3],array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(array[s_int, c, 3],array[s_int, c, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C12_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(array[s_int, c, 3],array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(array[s_int, c, 3],array[s_int, c, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(array[c, s_int, 3],array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(array[c, s_int, 3],array[c, s_int, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C13_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(array[c, s_int, 3],array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(array[c, s_int, 3],array[c, s_int, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(array[s_int, s_int, 3],array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(array[s_int, s_int, 3],array[s_int, s_int, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C14_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(array[s_int, s_int, 3],array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_prepend(array[s_int, s_int, 3],array[s_int, s_int, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(c, s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(c, s_int)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(c, s_int)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(s_int, c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(s_int, c)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(s_int, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(s_int, c)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(array[c, c, 3],c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(array[c, c, 3],c)<ARRAY[99999]);
++-----------------------+
+| col                   |
++-----------------------+
+| [1, 1, 3, 1]          |
+| [1, 1, 3, 1]          |
+| [1, 1, 3, 1]          |
+| [2, 2, 3, 2]          |
+| [2, 2, 3, 2]          |
+| [2, 2, 3, 2]          |
+| [null, null, 3, null] |
+| [null, null, 3, null] |
+| [null, null, 3, null] |
++-----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(array[c, c, 3],c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(array[c, c, 3],c)<ARRAY[99999]);
++-----------------------+
+| col                   |
++-----------------------+
+| [1, 1, 3, 1]          |
+| [1, 1, 3, 1]          |
+| [1, 1, 3, 1]          |
+| [2, 2, 3, 2]          |
+| [2, 2, 3, 2]          |
+| [2, 2, 3, 2]          |
+| [null, null, 3, null] |
+| [null, null, 3, null] |
+| [null, null, 3, null] |
++-----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(array[s_int, c, 3],s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(array[s_int, c, 3],s_int)<ARRAY[99999]);
++-----------------------+
+| col                   |
++-----------------------+
+| [1, 1, 3, 1]          |
+| [1, 2, 3, 1]          |
+| [1, null, 3, 1]       |
+| [2, 1, 3, 2]          |
+| [2, 2, 3, 2]          |
+| [2, null, 3, 2]       |
+| [null, 1, 3, null]    |
+| [null, 2, 3, null]    |
+| [null, null, 3, null] |
++-----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(array[s_int, c, 3],s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(array[s_int, c, 3],s_int)<ARRAY[99999]);
++-----------------------+
+| col                   |
++-----------------------+
+| [1, 1, 3, 1]          |
+| [1, 2, 3, 1]          |
+| [1, null, 3, 1]       |
+| [2, 1, 3, 2]          |
+| [2, 2, 3, 2]          |
+| [2, null, 3, 2]       |
+| [null, 1, 3, null]    |
+| [null, 2, 3, null]    |
+| [null, null, 3, null] |
++-----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(array[c, s_int, 3],c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(array[c, s_int, 3],c)<ARRAY[99999]);
++-----------------------+
+| col                   |
++-----------------------+
+| [1, 1, 3, 1]          |
+| [1, 2, 3, 1]          |
+| [1, null, 3, 1]       |
+| [2, 1, 3, 2]          |
+| [2, 2, 3, 2]          |
+| [2, null, 3, 2]       |
+| [null, 1, 3, null]    |
+| [null, 2, 3, null]    |
+| [null, null, 3, null] |
++-----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(array[c, s_int, 3],c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(array[c, s_int, 3],c)<ARRAY[99999]);
++-----------------------+
+| col                   |
++-----------------------+
+| [1, 1, 3, 1]          |
+| [1, 2, 3, 1]          |
+| [1, null, 3, 1]       |
+| [2, 1, 3, 2]          |
+| [2, 2, 3, 2]          |
+| [2, null, 3, 2]       |
+| [null, 1, 3, null]    |
+| [null, 2, 3, null]    |
+| [null, null, 3, null] |
++-----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(array[s_int, s_int, 3],s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(array[s_int, s_int, 3],s_int)<ARRAY[99999]);
++-----------------------+
+| col                   |
++-----------------------+
+| [1, 1, 3, 1]          |
+| [1, 1, 3, 1]          |
+| [1, 1, 3, 1]          |
+| [2, 2, 3, 2]          |
+| [2, 2, 3, 2]          |
+| [2, 2, 3, 2]          |
+| [null, null, 3, null] |
+| [null, null, 3, null] |
+| [null, null, 3, null] |
++-----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(array[s_int, s_int, 3],s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(array[s_int, s_int, 3],s_int)<ARRAY[99999]);
++-----------------------+
+| col                   |
++-----------------------+
+| [1, 1, 3, 1]          |
+| [1, 1, 3, 1]          |
+| [1, 1, 3, 1]          |
+| [2, 2, 3, 2]          |
+| [2, 2, 3, 2]          |
+| [2, 2, 3, 2]          |
+| [null, null, 3, null] |
+| [null, null, 3, null] |
+| [null, null, 3, null] |
++-----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(c,array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(c,array[c, c, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C7_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(c,array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(c,array[c, c, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(s_int,array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(s_int,array[s_int, c, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C8_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(s_int,array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(s_int,array[s_int, c, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(c,array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(c,array[c, s_int, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C9_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(c,array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(c,array[c, s_int, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(s_int,array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(s_int,array[s_int, s_int, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C10_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(s_int,array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(s_int,array[s_int, s_int, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(array[c, c, 3],array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(array[c, c, 3],array[c, c, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C11_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(array[c, c, 3],array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(array[c, c, 3],array[c, c, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(array[s_int, c, 3],array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(array[s_int, c, 3],array[s_int, c, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C12_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(array[s_int, c, 3],array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(array[s_int, c, 3],array[s_int, c, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(array[c, s_int, 3],array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(array[c, s_int, 3],array[c, s_int, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C13_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(array[c, s_int, 3],array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(array[c, s_int, 3],array[c, s_int, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(array[s_int, s_int, 3],array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(array[s_int, s_int, 3],array[s_int, s_int, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C14_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(array[s_int, s_int, 3],array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_append(array[s_int, s_int, 3],array[s_int, s_int, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(c, s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(c, s_int)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(c, s_int)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(s_int, c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(s_int, c)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(s_int, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(s_int, c)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(array[c, c, 3],c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(array[c, c, 3],c)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C3_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(array[c, c, 3],c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(array[c, c, 3],c)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(array[s_int, c, 3],s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(array[s_int, c, 3],s_int)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C4_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(array[s_int, c, 3],s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(array[s_int, c, 3],s_int)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(array[c, s_int, 3],c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(array[c, s_int, 3],c)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C5_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(array[c, s_int, 3],c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(array[c, s_int, 3],c)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(array[s_int, s_int, 3],s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(array[s_int, s_int, 3],s_int)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C6_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(array[s_int, s_int, 3],s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(array[s_int, s_int, 3],s_int)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(c,array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(c,array[c, c, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C7_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(c,array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(c,array[c, c, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(s_int,array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(s_int,array[s_int, c, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C8_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(s_int,array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(s_int,array[s_int, c, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(c,array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(c,array[c, s_int, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C9_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(c,array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(c,array[c, s_int, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(s_int,array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(s_int,array[s_int, s_int, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C10_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(s_int,array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(s_int,array[s_int, s_int, 3])<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(array[c, c, 3],array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(array[c, c, 3],array[c, c, 3])<ARRAY[99999]);
++--------------------------------+
+| col                            |
++--------------------------------+
+| [1, 1, 3, 1, 1, 3]             |
+| [1, 1, 3, 1, 1, 3]             |
+| [1, 1, 3, 1, 1, 3]             |
+| [2, 2, 3, 2, 2, 3]             |
+| [2, 2, 3, 2, 2, 3]             |
+| [2, 2, 3, 2, 2, 3]             |
+| [null, null, 3, null, null, 3] |
+| [null, null, 3, null, null, 3] |
+| [null, null, 3, null, null, 3] |
++--------------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C11_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(array[c, c, 3],array[c, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(array[c, c, 3],array[c, c, 3])<ARRAY[99999]);
++--------------------------------+
+| col                            |
++--------------------------------+
+| [1, 1, 3, 1, 1, 3]             |
+| [1, 1, 3, 1, 1, 3]             |
+| [1, 1, 3, 1, 1, 3]             |
+| [2, 2, 3, 2, 2, 3]             |
+| [2, 2, 3, 2, 2, 3]             |
+| [2, 2, 3, 2, 2, 3]             |
+| [null, null, 3, null, null, 3] |
+| [null, null, 3, null, null, 3] |
+| [null, null, 3, null, null, 3] |
++--------------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(array[s_int, c, 3],array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(array[s_int, c, 3],array[s_int, c, 3])<ARRAY[99999]);
++--------------------------------+
+| col                            |
++--------------------------------+
+| [1, 1, 3, 1, 1, 3]             |
+| [1, 2, 3, 1, 2, 3]             |
+| [1, null, 3, 1, null, 3]       |
+| [2, 1, 3, 2, 1, 3]             |
+| [2, 2, 3, 2, 2, 3]             |
+| [2, null, 3, 2, null, 3]       |
+| [null, 1, 3, null, 1, 3]       |
+| [null, 2, 3, null, 2, 3]       |
+| [null, null, 3, null, null, 3] |
++--------------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C12_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(array[s_int, c, 3],array[s_int, c, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(array[s_int, c, 3],array[s_int, c, 3])<ARRAY[99999]);
++--------------------------------+
+| col                            |
++--------------------------------+
+| [1, 1, 3, 1, 1, 3]             |
+| [1, 2, 3, 1, 2, 3]             |
+| [1, null, 3, 1, null, 3]       |
+| [2, 1, 3, 2, 1, 3]             |
+| [2, 2, 3, 2, 2, 3]             |
+| [2, null, 3, 2, null, 3]       |
+| [null, 1, 3, null, 1, 3]       |
+| [null, 2, 3, null, 2, 3]       |
+| [null, null, 3, null, null, 3] |
++--------------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(array[c, s_int, 3],array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(array[c, s_int, 3],array[c, s_int, 3])<ARRAY[99999]);
++--------------------------------+
+| col                            |
++--------------------------------+
+| [1, 1, 3, 1, 1, 3]             |
+| [1, 2, 3, 1, 2, 3]             |
+| [1, null, 3, 1, null, 3]       |
+| [2, 1, 3, 2, 1, 3]             |
+| [2, 2, 3, 2, 2, 3]             |
+| [2, null, 3, 2, null, 3]       |
+| [null, 1, 3, null, 1, 3]       |
+| [null, 2, 3, null, 2, 3]       |
+| [null, null, 3, null, null, 3] |
++--------------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C13_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(array[c, s_int, 3],array[c, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(array[c, s_int, 3],array[c, s_int, 3])<ARRAY[99999]);
++--------------------------------+
+| col                            |
++--------------------------------+
+| [1, 1, 3, 1, 1, 3]             |
+| [1, 2, 3, 1, 2, 3]             |
+| [1, null, 3, 1, null, 3]       |
+| [2, 1, 3, 2, 1, 3]             |
+| [2, 2, 3, 2, 2, 3]             |
+| [2, null, 3, 2, null, 3]       |
+| [null, 1, 3, null, 1, 3]       |
+| [null, 2, 3, null, 2, 3]       |
+| [null, null, 3, null, null, 3] |
++--------------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(array[s_int, s_int, 3],array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(array[s_int, s_int, 3],array[s_int, s_int, 3])<ARRAY[99999]);
++--------------------------------+
+| col                            |
++--------------------------------+
+| [1, 1, 3, 1, 1, 3]             |
+| [1, 1, 3, 1, 1, 3]             |
+| [1, 1, 3, 1, 1, 3]             |
+| [2, 2, 3, 2, 2, 3]             |
+| [2, 2, 3, 2, 2, 3]             |
+| [2, 2, 3, 2, 2, 3]             |
+| [null, null, 3, null, null, 3] |
+| [null, null, 3, null, null, 3] |
+| [null, null, 3, null, null, 3] |
++--------------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C14_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(array[s_int, s_int, 3],array[s_int, s_int, 3]) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_concat(array[s_int, s_int, 3],array[s_int, s_int, 3])<ARRAY[99999]);
++--------------------------------+
+| col                            |
++--------------------------------+
+| [1, 1, 3, 1, 1, 3]             |
+| [1, 1, 3, 1, 1, 3]             |
+| [1, 1, 3, 1, 1, 3]             |
+| [2, 2, 3, 2, 2, 3]             |
+| [2, 2, 3, 2, 2, 3]             |
+| [2, 2, 3, 2, 2, 3]             |
+| [null, null, 3, null, null, 3] |
+| [null, null, 3, null, null, 3] |
+| [null, null, 3, null, null, 3] |
++--------------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(c, 1, 2) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_slice(c, 1, 2)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(c, 1, 2) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_slice(c, 1, 2)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(s_int, 1, 2) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_slice(s_int, 1, 2)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(s_int, 1, 2) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_slice(s_int, 1, 2)<ARRAY[99999]);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array[c, c, 3],1, 2) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_slice(array[c, c, 3],1, 2)<ARRAY[99999]);
++--------+
+| col    |
++--------+
+| [1]    |
+| [1]    |
+| [1]    |
+| [2]    |
+| [2]    |
+| [2]    |
+| [null] |
+| [null] |
+| [null] |
++--------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array[c, c, 3],1, 2) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_slice(array[c, c, 3],1, 2)<ARRAY[99999]);
++--------+
+| col    |
++--------+
+| [1]    |
+| [1]    |
+| [1]    |
+| [2]    |
+| [2]    |
+| [2]    |
+| [null] |
+| [null] |
+| [null] |
++--------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array[s_int, c, 3],1, 2) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_slice(array[s_int, c, 3],1, 2)<ARRAY[99999]);
++--------+
+| col    |
++--------+
+| [1]    |
+| [1]    |
+| [1]    |
+| [2]    |
+| [2]    |
+| [2]    |
+| [null] |
+| [null] |
+| [null] |
++--------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array[s_int, c, 3],1, 2) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_slice(array[s_int, c, 3],1, 2)<ARRAY[99999]);
++--------+
+| col    |
++--------+
+| [1]    |
+| [1]    |
+| [1]    |
+| [2]    |
+| [2]    |
+| [2]    |
+| [null] |
+| [null] |
+| [null] |
++--------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array[c, s_int, 3],1, 2) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_slice(array[c, s_int, 3],1, 2)<ARRAY[99999]);
++--------+
+| col    |
++--------+
+| [1]    |
+| [1]    |
+| [1]    |
+| [2]    |
+| [2]    |
+| [2]    |
+| [null] |
+| [null] |
+| [null] |
++--------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array[c, s_int, 3],1, 2) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_slice(array[c, s_int, 3],1, 2)<ARRAY[99999]);
++--------+
+| col    |
++--------+
+| [1]    |
+| [1]    |
+| [1]    |
+| [2]    |
+| [2]    |
+| [2]    |
+| [null] |
+| [null] |
+| [null] |
++--------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array[s_int, s_int, 3],1, 2) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_slice(array[s_int, s_int, 3],1, 2)<ARRAY[99999]);
++--------+
+| col    |
++--------+
+| [1]    |
+| [1]    |
+| [1]    |
+| [2]    |
+| [2]    |
+| [2]    |
+| [null] |
+| [null] |
+| [null] |
++--------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array[s_int, s_int, 3],1, 2) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_slice(array[s_int, s_int, 3],1, 2)<ARRAY[99999]);
++--------+
+| col    |
++--------+
+| [1]    |
+| [1]    |
+| [1]    |
+| [2]    |
+| [2]    |
+| [2]    |
+| [null] |
+| [null] |
+| [null] |
++--------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(c, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_to_string(c, '|')<'0'
+       OR array_to_string(c, '|')>'0');
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(c, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_to_string(c, '|')<'0'
+       OR array_to_string(c, '|')>'0');
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(s_int, '|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_to_string(s_int, '|')<'0'
+       OR array_to_string(s_int, '|')>'0');
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(s_int, '|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_to_string(s_int, '|')<'0'
+       OR array_to_string(s_int, '|')>'0');
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(array[c, c, 3],'|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_to_string(array[c, c, 3],'|')<'0'
+       OR array_to_string(array[c, c, 3],'|')>'0');
++-------------+
+| col         |
++-------------+
+| 1|1|3       |
+| 1|1|3       |
+| 1|1|3       |
+| 2|2|3       |
+| 2|2|3       |
+| 2|2|3       |
+| null|null|3 |
+| null|null|3 |
+| null|null|3 |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(array[c, c, 3],'|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_to_string(array[c, c, 3],'|')<'0'
+       OR array_to_string(array[c, c, 3],'|')>'0');
++-------------+
+| col         |
++-------------+
+| 1|1|3       |
+| 1|1|3       |
+| 1|1|3       |
+| 2|2|3       |
+| 2|2|3       |
+| 2|2|3       |
+| null|null|3 |
+| null|null|3 |
+| null|null|3 |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(array[s_int, c, 3],'|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_to_string(array[s_int, c, 3],'|')<'0'
+       OR array_to_string(array[s_int, c, 3],'|')>'0');
++-------------+
+| col         |
++-------------+
+| 1|1|3       |
+| 1|2|3       |
+| 1|null|3    |
+| 2|1|3       |
+| 2|2|3       |
+| 2|null|3    |
+| null|1|3    |
+| null|2|3    |
+| null|null|3 |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(array[s_int, c, 3],'|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_to_string(array[s_int, c, 3],'|')<'0'
+       OR array_to_string(array[s_int, c, 3],'|')>'0');
++-------------+
+| col         |
++-------------+
+| 1|1|3       |
+| 1|2|3       |
+| 1|null|3    |
+| 2|1|3       |
+| 2|2|3       |
+| 2|null|3    |
+| null|1|3    |
+| null|2|3    |
+| null|null|3 |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(array[c, s_int, 3],'|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_to_string(array[c, s_int, 3],'|')<'0'
+       OR array_to_string(array[c, s_int, 3],'|')>'0');
++-------------+
+| col         |
++-------------+
+| 1|1|3       |
+| 1|2|3       |
+| 1|null|3    |
+| 2|1|3       |
+| 2|2|3       |
+| 2|null|3    |
+| null|1|3    |
+| null|2|3    |
+| null|null|3 |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(array[c, s_int, 3],'|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_to_string(array[c, s_int, 3],'|')<'0'
+       OR array_to_string(array[c, s_int, 3],'|')>'0');
++-------------+
+| col         |
++-------------+
+| 1|1|3       |
+| 1|2|3       |
+| 1|null|3    |
+| 2|1|3       |
+| 2|2|3       |
+| 2|null|3    |
+| null|1|3    |
+| null|2|3    |
+| null|null|3 |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(array[s_int, s_int, 3],'|') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_to_string(array[s_int, s_int, 3],'|')<'0'
+       OR array_to_string(array[s_int, s_int, 3],'|')>'0');
++-------------+
+| col         |
++-------------+
+| 1|1|3       |
+| 1|1|3       |
+| 1|1|3       |
+| 2|2|3       |
+| 2|2|3       |
+| 2|2|3       |
+| null|null|3 |
+| null|null|3 |
+| null|null|3 |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(array[s_int, s_int, 3],'|') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_to_string(array[s_int, s_int, 3],'|')<'0'
+       OR array_to_string(array[s_int, s_int, 3],'|')>'0');
++-------------+
+| col         |
++-------------+
+| 1|1|3       |
+| 1|1|3       |
+| 1|1|3       |
+| 2|2|3       |
+| 2|2|3       |
+| 2|2|3       |
+| null|null|3 |
+| null|null|3 |
+| null|null|3 |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(c, ',') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (string_to_array(c, '|')<ARRAY['99999']
+       OR string_to_array(c, ',') IS NULL);
++-----+
+| col |
++-----+
+| [1] |
+| [1] |
+| [1] |
+| [2] |
+| [2] |
+| [2] |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(c, ',') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (string_to_array(c, '|')<ARRAY['99999']
+       OR string_to_array(c, ',') IS NULL);
++-----+
+| col |
++-----+
+| [1] |
+| [1] |
+| [1] |
+| [2] |
+| [2] |
+| [2] |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(s_int, ',') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (string_to_array(s_int, '|')<ARRAY['99999']
+       OR string_to_array(s_int, ',') IS NULL);
++-----+
+| col |
++-----+
+| [1] |
+| [1] |
+| [1] |
+| [2] |
+| [2] |
+| [2] |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(s_int, ',') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (string_to_array(s_int, '|')<ARRAY['99999']
+       OR string_to_array(s_int, ',') IS NULL);
++-----+
+| col |
++-----+
+| [1] |
+| [1] |
+| [1] |
+| [2] |
+| [2] |
+| [2] |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(c||','||c||','||3, ',') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (string_to_array(c||','||c||','||3, '|')<ARRAY['99999']
+       OR string_to_array(c||','||c||','||3, ',') IS NULL);
++-----------+
+| col       |
++-----------+
+| [1, 1, 3] |
+| [1, 1, 3] |
+| [1, 1, 3] |
+| [2, 2, 3] |
+| [2, 2, 3] |
+| [2, 2, 3] |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(c||','||c||','||3, ',') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (string_to_array(c||','||c||','||3, '|')<ARRAY['99999']
+       OR string_to_array(c||','||c||','||3, ',') IS NULL);
++-----------+
+| col       |
++-----------+
+| [1, 1, 3] |
+| [1, 1, 3] |
+| [1, 1, 3] |
+| [2, 2, 3] |
+| [2, 2, 3] |
+| [2, 2, 3] |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(s_int||','||c||','||3, ',') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (string_to_array(s_int||','||c||','||3, ',')<ARRAY['99999']
+       OR string_to_array(s_int||','||c||','||3, ',') IS NULL);
++-----------+
+| col       |
++-----------+
+| [1, 1, 3] |
+| [1, 2, 3] |
+| [2, 1, 3] |
+| [2, 2, 3] |
+|           |
+|           |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(s_int||','||c||','||3, ',') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (string_to_array(s_int||','||c||','||3, ',')<ARRAY['99999']
+       OR string_to_array(s_int||','||c||','||3, ',') IS NULL);
++-----------+
+| col       |
++-----------+
+| [1, 1, 3] |
+| [1, 2, 3] |
+| [2, 1, 3] |
+| [2, 2, 3] |
+|           |
+|           |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(c||','||s_int||','||3, ',') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (string_to_array(c||','||s_int||','||3, ',')<ARRAY['99999']
+       OR string_to_array(c||','||s_int||','||3, ',') IS NULL);
++-----------+
+| col       |
++-----------+
+| [1, 1, 3] |
+| [1, 2, 3] |
+| [2, 1, 3] |
+| [2, 2, 3] |
+|           |
+|           |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C5_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(c||','||s_int||','||3, ',') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (string_to_array(c||','||s_int||','||3, ',')<ARRAY['99999']
+       OR string_to_array(c||','||s_int||','||3, ',') IS NULL);
++-----------+
+| col       |
++-----------+
+| [1, 1, 3] |
+| [1, 2, 3] |
+| [2, 1, 3] |
+| [2, 2, 3] |
+|           |
+|           |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(s_int||','||s_int||','||3, ',') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (string_to_array(s_int||','||s_int||','||3, ',')<ARRAY['99999']
+       OR string_to_array(s_int||','||s_int||','||3, ',') IS NULL);
++-----------+
+| col       |
++-----------+
+| [1, 1, 3] |
+| [1, 1, 3] |
+| [1, 1, 3] |
+| [2, 2, 3] |
+| [2, 2, 3] |
+| [2, 2, 3] |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C6_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(s_int||','||s_int||','||3, ',') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (string_to_array(s_int||','||s_int||','||3, ',')<ARRAY['99999']
+       OR string_to_array(s_int||','||s_int||','||3, ',') IS NULL);
++-----------+
+| col       |
++-----------+
+| [1, 1, 3] |
+| [1, 1, 3] |
+| [1, 1, 3] |
+| [2, 2, 3] |
+| [2, 2, 3] |
+| [2, 2, 3] |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_to_mv(c) IS NOT NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_to_mv(c) IS NOT NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_to_mv(s_int) IS NOT NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (array_to_mv(s_int) IS NOT NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(string_to_mv('1,2,3', ','), array['2', '3', '4']) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_filter_only(string_to_mv('1,2,3', ','), array['2', '3', '4']) IS NOT NULL
+       OR mv_filter_only(string_to_mv('1,2,3', ','), array['2', '3', '4']) IS NULL);
++-----------+
+| col       |
++-----------+
+| ["2","3"] |
+| ["2","3"] |
+| ["2","3"] |
+| ["2","3"] |
+| ["2","3"] |
+| ["2","3"] |
+| ["2","3"] |
+| ["2","3"] |
+| ["2","3"] |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(string_to_mv('1,2,3', ','), array['2', '3', '4']) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_filter_only(string_to_mv('1,2,3', ','), array['2', '3', '4']) IS NOT NULL
+       OR mv_filter_only(string_to_mv('1,2,3', ','), array['2', '3', '4']) IS NULL);
++-----------+
+| col       |
++-----------+
+| ["2","3"] |
+| ["2","3"] |
+| ["2","3"] |
+| ["2","3"] |
+| ["2","3"] |
+| ["2","3"] |
+| ["2","3"] |
+| ["2","3"] |
+| ["2","3"] |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(string_to_mv(cast(c AS char), ','), array['2', '3', '4']) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_filter_only(cast(c AS char),array['2', '3', '4']) IS NOT NULL
+       OR mv_filter_only(cast(c AS char),array['2', '3', '4']) IS NULL);
++-----+
+| col |
++-----+
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(string_to_mv(cast(c AS char), ','), array['2', '3', '4']) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_filter_only(cast(c AS char),array['2', '3', '4']) IS NOT NULL
+       OR mv_filter_only(cast(c AS char),array['2', '3', '4']) IS NULL);
++-----+
+| col |
++-----+
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(string_to_mv(cast(s_int AS char), ','), array['2', '3', '4']) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_filter_only(cast(s_int AS char),array['2', '3', '4']) IS NOT NULL
+       OR mv_filter_only(cast(s_int AS char),array['2', '3', '4']) IS NULL);
++-----+
+| col |
++-----+
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(string_to_mv(cast(s_int AS char), ','), array['2', '3', '4']) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_filter_only(cast(s_int AS char),array['2', '3', '4']) IS NOT NULL
+       OR mv_filter_only(cast(s_int AS char),array['2', '3', '4']) IS NULL);
++-----+
+| col |
++-----+
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(string_to_mv('1,2,3', ','), array['2', '3', '4']) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_filter_none(string_to_mv('1,2,3', ','), array['2', '3', '4']) IS NOT NULL
+       OR mv_filter_none(string_to_mv('1,2,3', ','), array['2', '3', '4']) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(string_to_mv('1,2,3', ','), array['2', '3', '4']) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_filter_none(string_to_mv('1,2,3', ','), array['2', '3', '4']) IS NOT NULL
+       OR mv_filter_none(string_to_mv('1,2,3', ','), array['2', '3', '4']) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(string_to_mv(cast(c AS char), ','), array['2', '3', '4']) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_filter_none(cast(c AS char),array['2', '3', '4']) IS NOT NULL
+       OR mv_filter_none(cast(c AS char),array['2', '3', '4']) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(string_to_mv(cast(c AS char), ','), array['2', '3', '4']) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_filter_none(cast(c AS char),array['2', '3', '4']) IS NOT NULL
+       OR mv_filter_none(cast(c AS char),array['2', '3', '4']) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(string_to_mv(cast(s_int AS char), ','), array['2', '3', '4']) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_filter_none(cast(s_int AS char),array['2', '3', '4']) IS NOT NULL
+       OR mv_filter_none(cast(s_int AS char),array['2', '3', '4']) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(string_to_mv(cast(s_int AS char), ','), array['2', '3', '4']) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_filter_none(cast(s_int AS char),array['2', '3', '4']) IS NOT NULL
+       OR mv_filter_none(cast(s_int AS char),array['2', '3', '4']) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_length(cast(c AS char))<99999
+       OR mv_length(cast(c AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_length(cast(c AS char))<99999
+       OR mv_length(cast(c AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_length(cast(s_int AS char))<99999
+       OR mv_length(cast(s_int AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_length(cast(s_int AS char))<99999
+       OR mv_length(cast(s_int AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(cast(c AS char), 0) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_offset(cast(c AS char), 0)<'99999'
+       OR mv_offset(cast(c AS char), 0) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(cast(c AS char), 0) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_offset(cast(c AS char), 0)<'99999'
+       OR mv_offset(cast(c AS char), 0) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(cast(s_int AS char), 0) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_offset(cast(s_int AS char), 0)<'99999'
+       OR mv_offset(cast(s_int AS char), 0) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(cast(s_int AS char), 0) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_offset(cast(s_int AS char), 0)<'99999'
+       OR mv_offset(cast(s_int AS char), 0) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(cast(c AS char), 1) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_ordinal(cast(c AS char), 1)<'99999'
+       OR mv_ordinal(cast(c AS char), 1) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(cast(c AS char), 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_ordinal(cast(c AS char), 1)<'99999'
+       OR mv_ordinal(cast(c AS char), 1) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(cast(s_int AS char), 1) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_ordinal(cast(s_int AS char), 1)<'99999'
+       OR mv_ordinal(cast(s_int AS char), 1) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(cast(s_int AS char), 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_ordinal(cast(s_int AS char), 1)<'99999'
+       OR mv_ordinal(cast(s_int AS char), 1) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(cast(c AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_contains(cast(c AS char), cast(c AS char)) IS TRUE
+       OR mv_contains(cast(c AS char), cast(c AS char)) IS FALSE
+       OR mv_contains(cast(c AS char), cast(c AS char)) IS NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(cast(c AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_contains(cast(c AS char), cast(c AS char)) IS TRUE
+       OR mv_contains(cast(c AS char), cast(c AS char)) IS FALSE
+       OR mv_contains(cast(c AS char), cast(c AS char)) IS NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(cast(c AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_contains(cast(c AS char), cast(s_int AS char)) IS TRUE
+       OR mv_contains(cast(c AS char), cast(s_int AS char)) IS FALSE
+       OR mv_contains(cast(c AS char), cast(s_int AS char)) IS NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(cast(c AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_contains(cast(c AS char), cast(s_int AS char)) IS TRUE
+       OR mv_contains(cast(c AS char), cast(s_int AS char)) IS FALSE
+       OR mv_contains(cast(c AS char), cast(s_int AS char)) IS NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(cast(s_int AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_contains(cast(s_int AS char), cast(c AS char)) IS TRUE
+       OR mv_contains(cast(s_int AS char), cast(c AS char)) IS FALSE
+       OR mv_contains(cast(s_int AS char), cast(c AS char)) IS NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(cast(s_int AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_contains(cast(s_int AS char), cast(c AS char)) IS TRUE
+       OR mv_contains(cast(s_int AS char), cast(c AS char)) IS FALSE
+       OR mv_contains(cast(s_int AS char), cast(c AS char)) IS NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(cast(s_int AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_contains(cast(s_int AS char), cast(s_int AS char)) IS TRUE
+       OR mv_contains(cast(s_int AS char), cast(s_int AS char)) IS FALSE
+       OR mv_contains(cast(s_int AS char), cast(s_int AS char)) IS NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(cast(s_int AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_contains(cast(s_int AS char), cast(s_int AS char)) IS TRUE
+       OR mv_contains(cast(s_int AS char), cast(s_int AS char)) IS FALSE
+       OR mv_contains(cast(s_int AS char), cast(s_int AS char)) IS NULL);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(cast(c AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_overlap(cast(c AS char), cast(c AS char)) IS TRUE
+       OR mv_overlap(cast(c AS char), cast(c AS char)) IS FALSE
+       OR mv_overlap(cast(c AS char), cast(c AS char)) IS NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(cast(c AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_overlap(cast(c AS char), cast(c AS char)) IS TRUE
+       OR mv_overlap(cast(c AS char), cast(c AS char)) IS FALSE
+       OR mv_overlap(cast(c AS char), cast(c AS char)) IS NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(cast(c AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_overlap(cast(c AS char), cast(s_int AS char)) IS TRUE
+       OR mv_overlap(cast(c AS char), cast(s_int AS char)) IS FALSE
+       OR mv_overlap(cast(c AS char), cast(s_int AS char)) IS NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(cast(c AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_overlap(cast(c AS char), cast(s_int AS char)) IS TRUE
+       OR mv_overlap(cast(c AS char), cast(s_int AS char)) IS FALSE
+       OR mv_overlap(cast(c AS char), cast(s_int AS char)) IS NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(cast(s_int AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_overlap(cast(s_int AS char), cast(c AS char)) IS TRUE
+       OR mv_overlap(cast(s_int AS char), cast(c AS char)) IS FALSE
+       OR mv_overlap(cast(s_int AS char), cast(c AS char)) IS NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(cast(s_int AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_overlap(cast(s_int AS char), cast(c AS char)) IS TRUE
+       OR mv_overlap(cast(s_int AS char), cast(c AS char)) IS FALSE
+       OR mv_overlap(cast(s_int AS char), cast(c AS char)) IS NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(cast(s_int AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_overlap(cast(s_int AS char), cast(s_int AS char)) IS TRUE
+       OR mv_overlap(cast(s_int AS char), cast(s_int AS char)) IS FALSE
+       OR mv_overlap(cast(s_int AS char), cast(s_int AS char)) IS NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(cast(s_int AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_overlap(cast(s_int AS char), cast(s_int AS char)) IS TRUE
+       OR mv_overlap(cast(s_int AS char), cast(s_int AS char)) IS FALSE
+       OR mv_overlap(cast(s_int AS char), cast(s_int AS char)) IS NULL);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(cast(c AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_offset_of(cast(c AS char), cast(c AS char)) IS NOT NULL
+       OR mv_offset_of(cast(c AS char), cast(c AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(cast(c AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_offset_of(cast(c AS char), cast(c AS char)) IS NOT NULL
+       OR mv_offset_of(cast(c AS char), cast(c AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(cast(c AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_offset_of(cast(c AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_offset_of(cast(c AS char), cast(s_int AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(cast(c AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_offset_of(cast(c AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_offset_of(cast(c AS char), cast(s_int AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(cast(s_int AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_offset_of(cast(s_int AS char), cast(c AS char)) IS NOT NULL
+       OR mv_offset_of(cast(s_int AS char), cast(c AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(cast(s_int AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_offset_of(cast(s_int AS char), cast(c AS char)) IS NOT NULL
+       OR mv_offset_of(cast(s_int AS char), cast(c AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(cast(s_int AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_offset_of(cast(s_int AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_offset_of(cast(s_int AS char), cast(s_int AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(cast(s_int AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_offset_of(cast(s_int AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_offset_of(cast(s_int AS char), cast(s_int AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(cast(c AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_ordinal_of(cast(c AS char), cast(c AS char)) IS NOT NULL
+       OR mv_ordinal_of(cast(c AS char), cast(c AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(cast(c AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_ordinal_of(cast(c AS char), cast(c AS char)) IS NOT NULL
+       OR mv_ordinal_of(cast(c AS char), cast(c AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(cast(c AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_ordinal_of(cast(c AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_ordinal_of(cast(c AS char), cast(s_int AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(cast(c AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_ordinal_of(cast(c AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_ordinal_of(cast(c AS char), cast(s_int AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(cast(s_int AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_ordinal_of(cast(s_int AS char), cast(c AS char)) IS NOT NULL
+       OR mv_ordinal_of(cast(s_int AS char), cast(c AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(cast(s_int AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_ordinal_of(cast(s_int AS char), cast(c AS char)) IS NOT NULL
+       OR mv_ordinal_of(cast(s_int AS char), cast(c AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(cast(s_int AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_ordinal_of(cast(s_int AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_ordinal_of(cast(s_int AS char), cast(s_int AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(cast(s_int AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_ordinal_of(cast(s_int AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_ordinal_of(cast(s_int AS char), cast(s_int AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend(cast(c AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_prepend(cast(c AS char), cast(c AS char)) IS NOT NULL
+       OR mv_prepend(cast(c AS char), cast(c AS char)) IS NULL);
++-----------+
+| col       |
++-----------+
+| ["1","1"] |
+| ["1","1"] |
+| ["1","1"] |
+| ["2","2"] |
+| ["2","2"] |
+| ["2","2"] |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend(cast(c AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_prepend(cast(c AS char), cast(c AS char)) IS NOT NULL
+       OR mv_prepend(cast(c AS char), cast(c AS char)) IS NULL);
++-----------+
+| col       |
++-----------+
+| ["1","1"] |
+| ["1","1"] |
+| ["1","1"] |
+| ["2","2"] |
+| ["2","2"] |
+| ["2","2"] |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend(cast(c AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_prepend(cast(c AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_prepend(cast(c AS char), cast(s_int AS char)) IS NULL);
++------------+
+| col        |
++------------+
+| ["1","1"]  |
+| ["1","2"]  |
+| ["2","1"]  |
+| ["2","2"]  |
+| [null,"1"] |
+| [null,"2"] |
+|            |
+|            |
+|            |
++------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend(cast(c AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_prepend(cast(c AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_prepend(cast(c AS char), cast(s_int AS char)) IS NULL);
++------------+
+| col        |
++------------+
+| ["1","1"]  |
+| ["1","2"]  |
+| ["2","1"]  |
+| ["2","2"]  |
+| [null,"1"] |
+| [null,"2"] |
+|            |
+|            |
+|            |
++------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend(cast(s_int AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_prepend(cast(s_int AS char), cast(c AS char)) IS NOT NULL
+       OR mv_prepend(cast(s_int AS char), cast(c AS char)) IS NULL);
++------------+
+| col        |
++------------+
+| ["1","1"]  |
+| ["1","2"]  |
+| ["2","1"]  |
+| ["2","2"]  |
+| [null,"1"] |
+| [null,"2"] |
+|            |
+|            |
+|            |
++------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend(cast(s_int AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_prepend(cast(s_int AS char), cast(c AS char)) IS NOT NULL
+       OR mv_prepend(cast(s_int AS char), cast(c AS char)) IS NULL);
++------------+
+| col        |
++------------+
+| ["1","1"]  |
+| ["1","2"]  |
+| ["2","1"]  |
+| ["2","2"]  |
+| [null,"1"] |
+| [null,"2"] |
+|            |
+|            |
+|            |
++------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend(cast(s_int AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_prepend(cast(s_int AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_prepend(cast(s_int AS char), cast(s_int AS char)) IS NULL);
++-----------+
+| col       |
++-----------+
+| ["1","1"] |
+| ["1","1"] |
+| ["1","1"] |
+| ["2","2"] |
+| ["2","2"] |
+| ["2","2"] |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend(cast(s_int AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_prepend(cast(s_int AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_prepend(cast(s_int AS char), cast(s_int AS char)) IS NULL);
++-----------+
+| col       |
++-----------+
+| ["1","1"] |
+| ["1","1"] |
+| ["1","1"] |
+| ["2","2"] |
+| ["2","2"] |
+| ["2","2"] |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(cast(c AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_append(cast(c AS char), cast(c AS char)) IS NOT NULL
+       OR mv_append(cast(c AS char), cast(c AS char)) IS NULL);
++-----------+
+| col       |
++-----------+
+| ["1","1"] |
+| ["1","1"] |
+| ["1","1"] |
+| ["2","2"] |
+| ["2","2"] |
+| ["2","2"] |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(cast(c AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_append(cast(c AS char), cast(c AS char)) IS NOT NULL
+       OR mv_append(cast(c AS char), cast(c AS char)) IS NULL);
++-----------+
+| col       |
++-----------+
+| ["1","1"] |
+| ["1","1"] |
+| ["1","1"] |
+| ["2","2"] |
+| ["2","2"] |
+| ["2","2"] |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(cast(c AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_append(cast(c AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_append(cast(c AS char), cast(s_int AS char)) IS NULL);
++------------+
+| col        |
++------------+
+| ["1","1"]  |
+| ["1","2"]  |
+| ["1",null] |
+| ["2","1"]  |
+| ["2","2"]  |
+| ["2",null] |
+|            |
+|            |
+|            |
++------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(cast(c AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_append(cast(c AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_append(cast(c AS char), cast(s_int AS char)) IS NULL);
++------------+
+| col        |
++------------+
+| ["1","1"]  |
+| ["1","2"]  |
+| ["1",null] |
+| ["2","1"]  |
+| ["2","2"]  |
+| ["2",null] |
+|            |
+|            |
+|            |
++------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(cast(s_int AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_append(cast(s_int AS char), cast(c AS char)) IS NOT NULL
+       OR mv_append(cast(s_int AS char), cast(c AS char)) IS NULL);
++------------+
+| col        |
++------------+
+| ["1","1"]  |
+| ["1","2"]  |
+| ["1",null] |
+| ["2","1"]  |
+| ["2","2"]  |
+| ["2",null] |
+|            |
+|            |
+|            |
++------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(cast(s_int AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_append(cast(s_int AS char), cast(c AS char)) IS NOT NULL
+       OR mv_append(cast(s_int AS char), cast(c AS char)) IS NULL);
++------------+
+| col        |
++------------+
+| ["1","1"]  |
+| ["1","2"]  |
+| ["1",null] |
+| ["2","1"]  |
+| ["2","2"]  |
+| ["2",null] |
+|            |
+|            |
+|            |
++------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(cast(s_int AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_append(cast(s_int AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_append(cast(s_int AS char), cast(s_int AS char)) IS NULL);
++-----------+
+| col       |
++-----------+
+| ["1","1"] |
+| ["1","1"] |
+| ["1","1"] |
+| ["2","2"] |
+| ["2","2"] |
+| ["2","2"] |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(cast(s_int AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_append(cast(s_int AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_append(cast(s_int AS char), cast(s_int AS char)) IS NULL);
++-----------+
+| col       |
++-----------+
+| ["1","1"] |
+| ["1","1"] |
+| ["1","1"] |
+| ["2","2"] |
+| ["2","2"] |
+| ["2","2"] |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(cast(c AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_concat(cast(c AS char), cast(c AS char)) IS NOT NULL
+       OR mv_concat(cast(c AS char), cast(c AS char)) IS NULL);
++-----------+
+| col       |
++-----------+
+| ["1","1"] |
+| ["1","1"] |
+| ["1","1"] |
+| ["2","2"] |
+| ["2","2"] |
+| ["2","2"] |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(cast(c AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_concat(cast(c AS char), cast(c AS char)) IS NOT NULL
+       OR mv_concat(cast(c AS char), cast(c AS char)) IS NULL);
++-----------+
+| col       |
++-----------+
+| ["1","1"] |
+| ["1","1"] |
+| ["1","1"] |
+| ["2","2"] |
+| ["2","2"] |
+| ["2","2"] |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(cast(c AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_concat(cast(c AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_concat(cast(c AS char), cast(s_int AS char)) IS NULL);
++-----------+
+| col       |
++-----------+
+| ["1","1"] |
+| ["1","2"] |
+| ["2","1"] |
+| ["2","2"] |
+|           |
+|           |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(cast(c AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_concat(cast(c AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_concat(cast(c AS char), cast(s_int AS char)) IS NULL);
++-----------+
+| col       |
++-----------+
+| ["1","1"] |
+| ["1","2"] |
+| ["2","1"] |
+| ["2","2"] |
+|           |
+|           |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(cast(s_int AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_concat(cast(s_int AS char), cast(c AS char)) IS NOT NULL
+       OR mv_concat(cast(s_int AS char), cast(c AS char)) IS NULL);
++-----------+
+| col       |
++-----------+
+| ["1","1"] |
+| ["1","2"] |
+| ["2","1"] |
+| ["2","2"] |
+|           |
+|           |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(cast(s_int AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_concat(cast(s_int AS char), cast(c AS char)) IS NOT NULL
+       OR mv_concat(cast(s_int AS char), cast(c AS char)) IS NULL);
++-----------+
+| col       |
++-----------+
+| ["1","1"] |
+| ["1","2"] |
+| ["2","1"] |
+| ["2","2"] |
+|           |
+|           |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(cast(s_int AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_concat(cast(s_int AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_concat(cast(s_int AS char), cast(s_int AS char)) IS NULL);
++-----------+
+| col       |
++-----------+
+| ["1","1"] |
+| ["1","1"] |
+| ["1","1"] |
+| ["2","2"] |
+| ["2","2"] |
+| ["2","2"] |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(cast(s_int AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_concat(cast(s_int AS char), cast(s_int AS char)) IS NOT NULL
+       OR mv_concat(cast(s_int AS char), cast(s_int AS char)) IS NULL);
++-----------+
+| col       |
++-----------+
+| ["1","1"] |
+| ["1","1"] |
+| ["1","1"] |
+| ["2","2"] |
+| ["2","2"] |
+| ["2","2"] |
+|           |
+|           |
+|           |
++-----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(cast(c AS char), 0, 1) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_slice(cast(c AS char), 0, 1) IS NOT NULL
+       OR mv_slice(cast(c AS char), 0, 1) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(cast(c AS char), 0, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_slice(cast(c AS char), 0, 1) IS NOT NULL
+       OR mv_slice(cast(c AS char), 0, 1) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(cast(s_int AS char), 0, 1) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_slice(cast(s_int AS char), 0, 1) IS NOT NULL
+       OR mv_slice(cast(s_int AS char), 0, 1) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(cast(s_int AS char), 0, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_slice(cast(s_int AS char), 0, 1) IS NOT NULL
+       OR mv_slice(cast(s_int AS char), 0, 1) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(cast(c AS char), ',') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_to_string(cast(c AS char), ',') IS NOT NULL
+       OR mv_to_string(cast(c AS char), ',') IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(cast(c AS char), ',') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_to_string(cast(c AS char), ',') IS NOT NULL
+       OR mv_to_string(cast(c AS char), ',') IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(cast(s_int AS char), ',') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_to_string(cast(s_int AS char), ',') IS NOT NULL
+       OR mv_to_string(cast(s_int AS char), ',') IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(cast(s_int AS char), ',') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mv_to_string(cast(s_int AS char), ',') IS NOT NULL
+       OR mv_to_string(cast(s_int AS char), ',') IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(cast(c AS char), ',') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (string_to_mv(cast(c AS char), ',') IS NOT NULL
+       OR string_to_mv(cast(c AS char), ',') IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(cast(c AS char), ',') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (string_to_mv(cast(c AS char), ',') IS NOT NULL
+       OR string_to_mv(cast(c AS char), ',') IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(cast(s_int AS char), ',') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (string_to_mv(cast(s_int AS char), ',') IS NOT NULL
+       OR string_to_mv(cast(s_int AS char), ',') IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(cast(s_int AS char), ',') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (string_to_mv(cast(s_int AS char), ',') IS NOT NULL
+       OR string_to_mv(cast(s_int AS char), ',') IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c, '$.') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_keys(c, '$.') IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c, '$.') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_keys(c, '$.') IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(s_int, '$.') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_keys(s_int, '$.') IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(s_int, '$.') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_keys(s_int, '$.') IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_object(KEY 'k' value c) IS NOT NULL);
++------------+
+| col        |
++------------+
+| {"k":1}    |
+| {"k":1}    |
+| {"k":1}    |
+| {"k":2}    |
+| {"k":2}    |
+| {"k":2}    |
+| {"k":null} |
+| {"k":null} |
+| {"k":null} |
++------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_object(KEY 'k' value c) IS NOT NULL);
++------------+
+| col        |
++------------+
+| {"k":1}    |
+| {"k":1}    |
+| {"k":1}    |
+| {"k":2}    |
+| {"k":2}    |
+| {"k":2}    |
+| {"k":null} |
+| {"k":null} |
+| {"k":null} |
++------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_object(KEY 'k' value s_int) IS NOT NULL);
++------------+
+| col        |
++------------+
+| {"k":1}    |
+| {"k":1}    |
+| {"k":1}    |
+| {"k":2}    |
+| {"k":2}    |
+| {"k":2}    |
+| {"k":null} |
+| {"k":null} |
+| {"k":null} |
++------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_object(KEY 'k' value s_int) IS NOT NULL);
++------------+
+| col        |
++------------+
+| {"k":1}    |
+| {"k":1}    |
+| {"k":1}    |
+| {"k":2}    |
+| {"k":2}    |
+| {"k":2}    |
+| {"k":null} |
+| {"k":null} |
+| {"k":null} |
++------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_paths(c) IS NOT NULL);
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_paths(c) IS NOT NULL);
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_paths(s_int) IS NOT NULL);
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_paths(s_int) IS NOT NULL);
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c, '$.') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_query(c, '$.') IS NOT NULL
+       OR json_query(c, '$.') IS NULL);
+java.lang.IllegalArgumentException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c, '$.') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_query(c, '$.') IS NOT NULL
+       OR json_query(c, '$.') IS NULL);
+java.lang.IllegalArgumentException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(s_int, '$.') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_query(s_int, '$.') IS NOT NULL
+       OR json_query(s_int, '$.') IS NULL);
+java.lang.IllegalArgumentException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(s_int, '$.') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_query(s_int, '$.') IS NOT NULL
+       OR json_query(s_int, '$.') IS NULL);
+java.lang.IllegalArgumentException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c, '$.') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_value(c, '$.') IS NOT NULL
+       OR json_value(c, '$.') IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c, '$.') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_value(c, '$.') IS NOT NULL
+       OR json_value(c, '$.') IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(s_int, '$.') AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_value(s_int, '$.') IS NOT NULL
+       OR json_value(s_int, '$.') IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(s_int, '$.') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (json_value(s_int, '$.') IS NOT NULL
+       OR json_value(s_int, '$.') IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (parse_json(cast(c AS char)) IS NOT NULL
+       OR parse_json(cast(c AS char)) IS NULL);
+java.lang.IllegalArgumentException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (parse_json(cast(c AS char)) IS NOT NULL
+       OR parse_json(cast(c AS char)) IS NULL);
+java.lang.IllegalArgumentException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (parse_json(cast(s_int AS char)) IS NOT NULL
+       OR parse_json(cast(s_int AS char)) IS NULL);
+java.lang.IllegalArgumentException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (parse_json(cast(s_int AS char)) IS NOT NULL
+       OR parse_json(cast(s_int AS char)) IS NULL);
+java.lang.IllegalArgumentException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (try_parse_json(cast(c AS char)) IS NOT NULL
+       OR try_parse_json(cast(c AS char)) IS NULL);
+java.lang.IllegalArgumentException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (try_parse_json(cast(c AS char)) IS NOT NULL
+       OR try_parse_json(cast(c AS char)) IS NULL);
+java.lang.IllegalArgumentException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (try_parse_json(cast(s_int AS char)) IS NOT NULL
+       OR try_parse_json(cast(s_int AS char)) IS NULL);
+java.lang.IllegalArgumentException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (try_parse_json(cast(s_int AS char)) IS NOT NULL
+       OR try_parse_json(cast(s_int AS char)) IS NULL);
+java.lang.IllegalArgumentException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(c) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (to_json_string(c) IS NOT NULL
+       OR to_json_string(c) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (to_json_string(c) IS NOT NULL
+       OR to_json_string(c) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(s_int) AS col
+FROM test_unnest,
+     unnest(a_int) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (to_json_string(s_int) IS NOT NULL
+       OR to_json_string(s_int) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (to_json_string(s_int) IS NOT NULL
+       OR to_json_string(s_int) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 937 Positive tests: 725 Negative tests: 212
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql_scalar_funcs.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql_scalar_funcs.iq
new file mode 100644
index 000000000000..758e183d6415
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_array_sql_scalar_funcs.iq
@@ -0,0 +1,7011 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaUnnest/array&numMergeBuffers=3
+!set outputformat mysql
+SELECT *
+FROM test_unnest;
++-------------------------+-------+--------+--------------+--------------+------------------+----------------+--------------------+---------+--------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| __time                  | s_int | s_null | a_bool       | a_int        | a_float          | a_str          | a_null             | a_empty | a_mixed                  | a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------+-------+--------+--------------+--------------+------------------+----------------+--------------------+---------+--------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| 2022-01-01 00:00:00.000 |     1 |        | [1, 0, null] | [1, 2, null] | [0.1, 0.2, null] | [S1, S2, null] | [null, null, null] | []      | [true, 1, 0.1, S1, null] | [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| 2022-02-01 00:00:00.000 |     2 |        | [null, 1, 0] | [null, 1, 2] | [null, 0.1, 0.2] | [null, S1, S2] | [null, null, null] | []      | [null, true, 1, 0.1, S1] | [[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"],[[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"],[[null,true,false],[null,1,2],[null,0.1,0.2],[null,"S1","S2"],[null,null,null],[],[null,true,1,0.1,"S1"]]]] |
+| 2022-03-01 00:00:00.000 |       |        | [0, null, 1] | [2, null, 1] | [0.2, null, 0.1] | [S2, null, S1] | [null, null, null] | []      | [S1, null, true, 1, 0.1] | [[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1],[[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1],[[false,null,true],[2,null,1],[0.2,null,0.1],["S2",null,"S1"],[null,null,null],[],["S1",null,true,1,0.1]]]] |
++-------------------------+-------+--------+--------------+--------------+------------------+----------------+--------------------+---------+--------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B1_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT pi+pi AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((pi+pi)<99999
+       OR (pi+pi) IS NULL);
++-------------------+
+| col               |
++-------------------+
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
++-------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B1_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT pi AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (pi<99999
+       OR pi IS NULL);
++-------------------+
+| col               |
++-------------------+
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
++-------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B2_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(c)+abs(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((abs(c)+abs(c))<99999
+       OR (abs(c)+abs(c)) IS NULL);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   4 |
+|   4 |
+|   4 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B2_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (abs(c+c)<99999
+       OR abs(c+c) IS NULL);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   4 |
+|   4 |
+|   4 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B2_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(c)+abs(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((abs(c)+abs(s_int))<99999
+       OR (abs(c)+abs(s_int)) IS NULL);
++-----+
+| col |
++-----+
+|   2 |
+|   3 |
+|   3 |
+|   4 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B2_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((abs(c)+abs(s_int))<99999
+       OR (abs(c)+abs(s_int)) IS NULL);
++-----+
+| col |
++-----+
+|   2 |
+|   3 |
+|   3 |
+|   4 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B3_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(c)+ceil(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((ceil(c)+ceil(c))<99999
+       OR (ceil(c)+ceil(c)) IS NULL);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   4 |
+|   4 |
+|   4 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B3_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (ceil(c+c)<99999
+       OR ceil(c+c) IS NULL);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   4 |
+|   4 |
+|   4 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B3_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(c)+ceil(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((ceil(c)+ceil(s_int))<99999
+       OR (ceil(c)+ceil(s_int)) IS NULL);
++-----+
+| col |
++-----+
+|   2 |
+|   3 |
+|   3 |
+|   4 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B3_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (ceil(c+s_int)<99999
+       OR ceil(c+s_int) IS NULL);
++-----+
+| col |
++-----+
+|   2 |
+|   3 |
+|   3 |
+|   4 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B4_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(c)+exp(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((exp(c)+exp(c))<99999
+       OR (exp(c)+exp(c)) IS NULL);
++------------------+
+| col              |
++------------------+
+| 14.7781121978613 |
+| 14.7781121978613 |
+| 14.7781121978613 |
+| 5.43656365691809 |
+| 5.43656365691809 |
+| 5.43656365691809 |
+|                  |
+|                  |
+|                  |
++------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B4_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (exp(c+c)<99999
+       OR exp(c+c) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 54.598150033144236 |
+| 54.598150033144236 |
+| 54.598150033144236 |
+|   7.38905609893065 |
+|   7.38905609893065 |
+|   7.38905609893065 |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B4_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(c)+exp(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((exp(c)+exp(s_int))<99999
+       OR (exp(c)+exp(s_int)) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 10.107337927389695 |
+| 10.107337927389695 |
+|   14.7781121978613 |
+|   5.43656365691809 |
+|                    |
+|                    |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B4_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (exp(c+s_int)<99999
+       OR exp(c+s_int) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 20.085536923187668 |
+| 20.085536923187668 |
+| 54.598150033144236 |
+|   7.38905609893065 |
+|                    |
+|                    |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B5_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(c)+floor(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((floor(c)+floor(c))<99999
+       OR (floor(c)+floor(c)) IS NULL);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   4 |
+|   4 |
+|   4 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B5_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (floor(c+c)<99999
+       OR floor(c+c) IS NULL);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   4 |
+|   4 |
+|   4 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B5_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(c)+floor(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((floor(c)+floor(s_int))<99999
+       OR (floor(c)+floor(s_int)) IS NULL);
++-----+
+| col |
++-----+
+|   2 |
+|   3 |
+|   3 |
+|   4 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A3_B5_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (floor(c+s_int)<99999
+       OR floor(c+s_int)<99999 IS NULL);
++-----+
+| col |
++-----+
+|   2 |
+|   3 |
+|   3 |
+|   4 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B6_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(c)+ln(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((ln(c)+ln(c))<99999
+       OR (ln(c)+ln(c)) IS NULL);
++--------------------+
+| col                |
++--------------------+
+|                0.0 |
+|                0.0 |
+|                0.0 |
+| 1.3862943611198906 |
+| 1.3862943611198906 |
+| 1.3862943611198906 |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B6_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (ln(c+c)<99999
+       OR ln(c+c) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 0.6931471805599453 |
+| 0.6931471805599453 |
+| 0.6931471805599453 |
+| 1.3862943611198906 |
+| 1.3862943611198906 |
+| 1.3862943611198906 |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B6_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(c)+ln(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((ln(c)+ln(s_int))<99999
+       OR (ln(c)+ln(s_int)) IS NULL);
++--------------------+
+| col                |
++--------------------+
+|                0.0 |
+| 0.6931471805599453 |
+| 0.6931471805599453 |
+| 1.3862943611198906 |
+|                    |
+|                    |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B6_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (ln(c+s_int)<99999
+       OR ln(c+s_int)<99999 IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 0.6931471805599453 |
+| 1.0986122886681098 |
+| 1.0986122886681098 |
+| 1.3862943611198906 |
+|                    |
+|                    |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B7_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(c)+log10(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((log10(c)+log10(c))<99999
+       OR (log10(c)+log10(c)) IS NULL);
++--------------------+
+| col                |
++--------------------+
+|                0.0 |
+|                0.0 |
+|                0.0 |
+| 0.6020599913279624 |
+| 0.6020599913279624 |
+| 0.6020599913279624 |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B7_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (log10(c+c)<99999
+       OR log10(c+c) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 0.3010299956639812 |
+| 0.3010299956639812 |
+| 0.3010299956639812 |
+| 0.6020599913279624 |
+| 0.6020599913279624 |
+| 0.6020599913279624 |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B7_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(c)+log10(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((log10(c)+log10(s_int))<99999
+       OR (log10(c)+log10(s_int)) IS NULL);
++--------------------+
+| col                |
++--------------------+
+|                0.0 |
+| 0.3010299956639812 |
+| 0.3010299956639812 |
+| 0.6020599913279624 |
+|                    |
+|                    |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B7_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (log10(c+s_int)<99999
+       OR log10(c+s_int) IS NULL);
++---------------------+
+| col                 |
++---------------------+
+|  0.3010299956639812 |
+| 0.47712125471966244 |
+| 0.47712125471966244 |
+|  0.6020599913279624 |
+|                     |
+|                     |
+|                     |
+|                     |
+|                     |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B8_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(c, 1)+power(c, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((power(c, 1)+power(c, 1))<99999
+       OR (power(c, 1)+power(c, 1)) IS NULL);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B8_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(c+c, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (power(c+c, 1)<99999
+       OR power(c+c, 1) IS NULL);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B8_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(c, 1)+power(s_int, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((power(c, 1)+power(s_int, 1))<99999
+       OR (power(c, 1)+power(s_int, 1)) IS NULL);
++-----+
+| col |
++-----+
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B8_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(c+s_int, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (power(c+s_int, 1)<99999
+       OR power(c+s_int, 1) IS NULL);
++-----+
+| col |
++-----+
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B9_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(c)+sqrt(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((sqrt(c)+sqrt(c))<99999
+       OR (sqrt(c)+sqrt(c)) IS NULL);
++--------------------+
+| col                |
++--------------------+
+|                2.0 |
+|                2.0 |
+|                2.0 |
+| 2.8284271247461903 |
+| 2.8284271247461903 |
+| 2.8284271247461903 |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B9_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (sqrt(c+c)<99999
+       OR sqrt(c+c) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 1.4142135623730951 |
+| 1.4142135623730951 |
+| 1.4142135623730951 |
+|                2.0 |
+|                2.0 |
+|                2.0 |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B9_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(c)+sqrt(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((sqrt(c)+sqrt(s_int))<99999
+       OR (sqrt(c)+sqrt(s_int)) IS NULL);
++--------------------+
+| col                |
++--------------------+
+|                2.0 |
+|  2.414213562373095 |
+|  2.414213562373095 |
+| 2.8284271247461903 |
+|                    |
+|                    |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B9_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (sqrt(c+s_int)<99999
+       OR sqrt(c+s_int) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 1.4142135623730951 |
+| 1.7320508075688772 |
+| 1.7320508075688772 |
+|                2.0 |
+|                    |
+|                    |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B10_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(cast(c AS decimal), 1)+truncate(cast(c AS decimal), 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((truncate(cast(c AS decimal), 1)+truncate(cast(c AS decimal), 1))<99999
+       OR (truncate(cast(c AS decimal), 1)+truncate(cast(c AS decimal), 1)) IS NULL);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B10_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(cast(c AS decimal)+cast(c AS decimal), 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (truncate(cast(c AS decimal)+cast(c AS decimal), 1)<99999
+       OR truncate(cast(c AS decimal)+cast(c AS decimal), 1) IS NULL);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B10_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(cast(c AS decimal), 1)+truncate(s_int, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((truncate(cast(c AS decimal), 1)+truncate(s_int, 1))<99999
+       OR (truncate(cast(c AS decimal), 1)+truncate(s_int, 1)) IS NULL);
++-----+
+| col |
++-----+
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B10_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(cast(c AS decimal)+s_int, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (truncate(cast(c AS decimal)+s_int, 1)<99999
+       OR truncate(cast(c AS decimal)+s_int, 1) IS NULL);
++-----+
+| col |
++-----+
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B11_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(cast(c AS decimal), 1)+trunc(cast(c AS decimal), 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((trunc(cast(c AS decimal), 1)+trunc(cast(c AS decimal), 1))<99999
+       OR (trunc(cast(c AS decimal), 1)+trunc(cast(c AS decimal), 1)) IS NULL);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B11_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(cast(c AS decimal)+cast(c AS decimal), 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (trunc(cast(c AS decimal)+cast(c AS decimal), 1)<99999
+       OR trunc(cast(c AS decimal)+cast(c AS decimal), 1) IS NULL);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B11_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(cast(c AS decimal), 1)+trunc(s_int, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((trunc(cast(c AS decimal), 1)+trunc(s_int, 1))<99999
+       OR (trunc(cast(c AS decimal), 1)+trunc(s_int, 1)) IS NULL);
++-----+
+| col |
++-----+
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B11_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(cast(c AS decimal)+s_int, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (trunc(cast(c AS decimal)+s_int, 1)<99999
+       OR trunc(cast(c AS decimal)+s_int, 1) IS NULL);
++-----+
+| col |
++-----+
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B12_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(cast(c AS decimal), 1)+round(cast(c AS decimal), 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((round(cast(c AS decimal), 1)+round(cast(c AS decimal), 1))<99999
+       OR (round(cast(c AS decimal), 1)+round(cast(c AS decimal), 1)) IS NULL);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B12_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(cast(c AS decimal)+cast(c AS decimal), 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (round(cast(c AS decimal)+cast(c AS decimal), 1)<99999
+       OR round(cast(c AS decimal)+cast(c AS decimal), 1) IS NULL);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B12_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(cast(c AS decimal), 1)+round(s_int, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((round(cast(c AS decimal), 1)+round(s_int, 1))<99999
+       OR (round(cast(c AS decimal), 1)+round(s_int, 1)) IS NULL);
++-----+
+| col |
++-----+
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B12_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(cast(c AS decimal)+s_int, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (round(cast(c AS decimal)+s_int, 1)<99999
+       OR round(cast(c AS decimal)+s_int, 1) IS NULL);
++-----+
+| col |
++-----+
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B13_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(c, 2)+mod(c, 2) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((mod(c, 2)+mod(c, 2))<99999
+       OR (mod(c, 2)+mod(c, 2))<99999 IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B13_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(c, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mod(c, c)<99999
+       OR mod(c, c) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B13_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(c, 2)+mod(s_int, 2) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((mod(c, 2)+mod(s_int, 2))<99999
+       OR (mod(c, 2)+mod(s_int, 2)) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   1 |
+|   2 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B13_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (mod(c, s_int)<99999
+       OR mod(c, s_int) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   1 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B14_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(c)+sin(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((sin(c)+sin(c))<99999
+       OR (sin(c)+sin(c)) IS NULL);
++--------------------+
+| col                |
++--------------------+
+|  1.682941969615793 |
+|  1.682941969615793 |
+|  1.682941969615793 |
+| 1.8185948536513634 |
+| 1.8185948536513634 |
+| 1.8185948536513634 |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B14_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (sin(c+c)<99999
+       OR sin(c+c) IS NULL);
++---------------------+
+| col                 |
++---------------------+
+| -0.7568024953079282 |
+| -0.7568024953079282 |
+| -0.7568024953079282 |
+|  0.9092974268256817 |
+|  0.9092974268256817 |
+|  0.9092974268256817 |
+|                     |
+|                     |
+|                     |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B14_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(c)+sin(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((sin(c)+sin(s_int))<99999
+       OR (sin(c)+sin(s_int)) IS NULL);
++--------------------+
+| col                |
++--------------------+
+|  1.682941969615793 |
+| 1.7507684116335782 |
+| 1.7507684116335782 |
+| 1.8185948536513634 |
+|                    |
+|                    |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B14_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (sin(c+s_int)<99999
+       OR sin(c+s_int)<99999 IS NULL);
++---------------------+
+| col                 |
++---------------------+
+| -0.7568024953079282 |
+|  0.1411200080598672 |
+|  0.1411200080598672 |
+|  0.9092974268256817 |
+|                     |
+|                     |
+|                     |
+|                     |
+|                     |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B15_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(c)+cos(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((cos(c)+cos(c))<99999
+       OR (cos(c)+cos(c)) IS NULL);
++---------------------+
+| col                 |
++---------------------+
+| -0.8322936730942848 |
+| -0.8322936730942848 |
+| -0.8322936730942848 |
+|  1.0806046117362795 |
+|  1.0806046117362795 |
+|  1.0806046117362795 |
+|                     |
+|                     |
+|                     |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B15_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (cos(c+c)<99999
+       OR cos(c+c) IS NULL);
++---------------------+
+| col                 |
++---------------------+
+| -0.4161468365471424 |
+| -0.4161468365471424 |
+| -0.4161468365471424 |
+| -0.6536436208636119 |
+| -0.6536436208636119 |
+| -0.6536436208636119 |
+|                     |
+|                     |
+|                     |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B15_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(c)+cos(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((cos(c)+cos(s_int))<99999
+       OR (cos(c)+cos(s_int)) IS NULL);
++---------------------+
+| col                 |
++---------------------+
+| -0.8322936730942848 |
+| 0.12415546932099736 |
+| 0.12415546932099736 |
+|  1.0806046117362795 |
+|                     |
+|                     |
+|                     |
+|                     |
+|                     |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B15_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (cos(c+s_int)<99999
+       OR cos(c+s_int) IS NULL);
++---------------------+
+| col                 |
++---------------------+
+| -0.4161468365471424 |
+| -0.6536436208636119 |
+| -0.9899924966004454 |
+| -0.9899924966004454 |
+|                     |
+|                     |
+|                     |
+|                     |
+|                     |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B16_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(c)+tan(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((tan(c)+tan(c))<99999
+       OR (tan(c)+tan(c)) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| -4.370079726523038 |
+| -4.370079726523038 |
+| -4.370079726523038 |
+| 3.1148154493098046 |
+| 3.1148154493098046 |
+| 3.1148154493098046 |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B16_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (tan(c+c)<99999
+       OR tan(c+c) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| -2.185039863261519 |
+| -2.185039863261519 |
+| -2.185039863261519 |
+| 1.1578212823495775 |
+| 1.1578212823495775 |
+| 1.1578212823495775 |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B16_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(c)+tan(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((tan(c)+tan(s_int))<99999
+       OR (tan(c)+tan(s_int)) IS NULL);
++---------------------+
+| col                 |
++---------------------+
+| -0.6276321386066166 |
+| -0.6276321386066166 |
+|  -4.370079726523038 |
+|  3.1148154493098046 |
+|                     |
+|                     |
+|                     |
+|                     |
+|                     |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B16_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (tan(c+s_int)<99999
+       OR tan(c+s_int) IS NULL);
++---------------------+
+| col                 |
++---------------------+
+| -0.1425465430742778 |
+| -0.1425465430742778 |
+|  -2.185039863261519 |
+|  1.1578212823495775 |
+|                     |
+|                     |
+|                     |
+|                     |
+|                     |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B17_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(c)+cot(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((cot(c)+cot(c))<99999
+       OR (cot(c)+cot(c)) IS NULL);
++---------------------+
+| col                 |
++---------------------+
+| -0.9153151087205715 |
+| -0.9153151087205715 |
+| -0.9153151087205715 |
+|  1.2841852318686615 |
+|  1.2841852318686615 |
+|  1.2841852318686615 |
+|                     |
+|                     |
+|                     |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B17_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (cot(c+c)<99999
+       OR cot(c+c) IS NULL);
++----------------------+
+| col                  |
++----------------------+
+| -0.45765755436028577 |
+| -0.45765755436028577 |
+| -0.45765755436028577 |
+|   0.8636911544506167 |
+|   0.8636911544506167 |
+|   0.8636911544506167 |
+|                      |
+|                      |
+|                      |
++----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B17_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(c)+cot(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((cot(c)+cot(s_int))<99999
+       OR (cot(c)+cot(s_int)) IS NULL);
++---------------------+
+| col                 |
++---------------------+
+| -0.9153151087205715 |
+|   0.184435061574045 |
+|   0.184435061574045 |
+|  1.2841852318686615 |
+|                     |
+|                     |
+|                     |
+|                     |
+|                     |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B17_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (cot(c+s_int)<99999
+       OR cot(c+s_int) IS NULL);
++----------------------+
+| col                  |
++----------------------+
+| -0.45765755436028577 |
+|   -7.015252551434534 |
+|   -7.015252551434534 |
+|   0.8636911544506167 |
+|                      |
+|                      |
+|                      |
+|                      |
+|                      |
++----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B18_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(c)+asin(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((asin(c)+asin(c))<99999
+       OR (asin(c)+asin(c)) IS NULL);
++-------------------+
+| col               |
++-------------------+
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+|                   |
+|                   |
+|                   |
++-------------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B18_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (asin(c+c)<99999
+       OR asin(c+c)<99999 IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B18_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(c)+asin(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((asin(c)+asin(s_int))<99999
+       OR (asin(c)+asin(s_int)) IS NULL);
++-------------------+
+| col               |
++-------------------+
+| 3.141592653589793 |
+|                   |
+|                   |
+|                   |
+|                   |
+|                   |
++-------------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B18_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (asin(c+s_int)<99999
+       OR asin(c+s_int)<99999 IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B19_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(c)+acos(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((acos(c)+acos(c))<99999
+       OR (acos(c)+acos(c)) IS NULL);
++-----+
+| col |
++-----+
+| 0.0 |
+| 0.0 |
+| 0.0 |
+|     |
+|     |
+|     |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B19_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (acos(c+c)<99999
+       OR acos(c+c) IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B19_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(c)+acos(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((acos(c)+acos(s_int))<99999
+       OR (acos(c)+acos(s_int)) IS NULL);
++-----+
+| col |
++-----+
+| 0.0 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B19_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (acos(c+s_int)<99999
+       OR acos(c+s_int) IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B20_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(c)+atan(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((atan(c)+atan(c))<99999
+       OR (atan(c)+atan(c)) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 1.5707963267948966 |
+| 1.5707963267948966 |
+| 1.5707963267948966 |
+|  2.214297435588181 |
+|  2.214297435588181 |
+|  2.214297435588181 |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B20_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (atan(c+c)<99999
+       OR atan(c+c) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 1.1071487177940904 |
+| 1.1071487177940904 |
+| 1.1071487177940904 |
+| 1.3258176636680326 |
+| 1.3258176636680326 |
+| 1.3258176636680326 |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B20_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(c)+atan(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((atan(c)+atan(s_int))<99999
+       OR (atan(c)+atan(s_int)) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 1.5707963267948966 |
+| 1.8925468811915387 |
+| 1.8925468811915387 |
+|  2.214297435588181 |
+|                    |
+|                    |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B20_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (atan(c+s_int)<99999
+       OR atan(c+s_int) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 1.1071487177940904 |
+| 1.2490457723982544 |
+| 1.2490457723982544 |
+| 1.3258176636680326 |
+|                    |
+|                    |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B21_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(c, 1)+atan2(c, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((atan2(c, 1)+atan2(c, 1))<99999
+       OR (atan2(c, 1)+atan2(c, 1)) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 1.5707963267948966 |
+| 1.5707963267948966 |
+| 1.5707963267948966 |
+|  2.214297435588181 |
+|  2.214297435588181 |
+|  2.214297435588181 |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B21_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(c, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (atan2(c, c)<99999
+       OR atan2(c, c) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 0.7853981633974483 |
+| 0.7853981633974483 |
+| 0.7853981633974483 |
+| 0.7853981633974483 |
+| 0.7853981633974483 |
+| 0.7853981633974483 |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B21_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(c, 1)+atan2(s_int, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((atan2(c, 1)+atan2(s_int, 1))<99999
+       OR (atan2(c, 1)+atan2(s_int, 1)) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 1.5707963267948966 |
+| 1.8925468811915387 |
+| 1.8925468811915387 |
+|  2.214297435588181 |
+|                    |
+|                    |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B21_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (atan2(c, s_int)<99999
+       OR atan2(c, s_int) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 0.4636476090008061 |
+| 0.7853981633974483 |
+| 0.7853981633974483 |
+| 1.1071487177940904 |
+|                    |
+|                    |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B22_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(c)+degrees(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((degrees(c)+degrees(c))<99999
+       OR (degrees(c)+degrees(c)) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 114.59155902616465 |
+| 114.59155902616465 |
+| 114.59155902616465 |
+|  229.1831180523293 |
+|  229.1831180523293 |
+|  229.1831180523293 |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B22_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (degrees(c+c)<99999
+       OR degrees(c+c) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 114.59155902616465 |
+| 114.59155902616465 |
+| 114.59155902616465 |
+|  229.1831180523293 |
+|  229.1831180523293 |
+|  229.1831180523293 |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B22_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(c)+degrees(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((degrees(c)+degrees(s_int))<99999
+       OR (degrees(c)+degrees(s_int)) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 114.59155902616465 |
+| 171.88733853924697 |
+| 171.88733853924697 |
+|  229.1831180523293 |
+|                    |
+|                    |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B22_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (degrees(c+s_int)<99999
+       OR degrees(c+s_int) IS NULL);
++--------------------+
+| col                |
++--------------------+
+| 114.59155902616465 |
+| 171.88733853924697 |
+| 171.88733853924697 |
+|  229.1831180523293 |
+|                    |
+|                    |
+|                    |
+|                    |
+|                    |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B23_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(c)+radians(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((radians(c)+radians(c))<99999
+       OR (radians(c)+radians(c)) IS NULL);
++---------------------+
+| col                 |
++---------------------+
+| 0.03490658503988659 |
+| 0.03490658503988659 |
+| 0.03490658503988659 |
+| 0.06981317007977318 |
+| 0.06981317007977318 |
+| 0.06981317007977318 |
+|                     |
+|                     |
+|                     |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B23_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (radians(c+c)<99999
+       OR radians(c+c) IS NULL);
++---------------------+
+| col                 |
++---------------------+
+| 0.03490658503988659 |
+| 0.03490658503988659 |
+| 0.03490658503988659 |
+| 0.06981317007977318 |
+| 0.06981317007977318 |
+| 0.06981317007977318 |
+|                     |
+|                     |
+|                     |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B23_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(c)+radians(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((radians(c)+radians(s_int))<99999
+       OR (radians(c)+radians(s_int)) IS NULL);
++---------------------+
+| col                 |
++---------------------+
+| 0.03490658503988659 |
+| 0.05235987755982989 |
+| 0.05235987755982989 |
+| 0.06981317007977318 |
+|                     |
+|                     |
+|                     |
+|                     |
+|                     |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B23_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (radians(c+s_int)<99999
+       OR radians(c+s_int) IS NULL);
++---------------------+
+| col                 |
++---------------------+
+| 0.03490658503988659 |
+| 0.05235987755982989 |
+| 0.05235987755982989 |
+| 0.06981317007977318 |
+|                     |
+|                     |
+|                     |
+|                     |
+|                     |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B24_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(c, 1)+bitwise_and(c, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((bitwise_and(c, 1)+bitwise_and(c, 1))<99999
+       OR (bitwise_and(c, 1)+bitwise_and(c, 1)) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B24_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(c, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (bitwise_and(c, c)<99999
+       OR bitwise_and(c, c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B24_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(c, 1)+bitwise_and(s_int, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((bitwise_and(c, 1)+bitwise_and(s_int, 1))<99999
+       OR (bitwise_and(c, 1)+bitwise_and(s_int, 1)) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   1 |
+|   2 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B24_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (bitwise_and(c, s_int)<99999
+       OR bitwise_and(c, s_int) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   1 |
+|   2 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B25_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(c)+bitwise_complement(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((bitwise_complement(c)+bitwise_complement(c))<99999
+       OR (bitwise_complement(c)+bitwise_complement(c)) IS NULL);
++-----+
+| col |
++-----+
+|  -4 |
+|  -4 |
+|  -4 |
+|  -6 |
+|  -6 |
+|  -6 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B25_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (bitwise_complement(c+c)<99999
+       OR bitwise_complement(c+c) IS NULL);
++-----+
+| col |
++-----+
+|  -3 |
+|  -3 |
+|  -3 |
+|  -5 |
+|  -5 |
+|  -5 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B25_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(c)+bitwise_complement(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((bitwise_complement(c)+bitwise_complement(s_int))<99999
+       OR (bitwise_complement(c)+bitwise_complement(s_int)) IS NULL);
++-----+
+| col |
++-----+
+|  -4 |
+|  -5 |
+|  -5 |
+|  -6 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B25_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (bitwise_complement(c+s_int)<99999
+       OR bitwise_complement(c+s_int) IS NULL);
++-----+
+| col |
++-----+
+|  -3 |
+|  -4 |
+|  -4 |
+|  -5 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B26_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(cast(c AS DOUBLE))+bitwise_convert_double_to_long_bits(cast(c AS DOUBLE)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((bitwise_convert_double_to_long_bits(cast(c AS DOUBLE))+bitwise_convert_double_to_long_bits(cast(c AS DOUBLE)))>0
+       OR (bitwise_convert_double_to_long_bits(cast(c AS DOUBLE))+bitwise_convert_double_to_long_bits(cast(c AS DOUBLE)))<0
+       OR (bitwise_convert_double_to_long_bits(cast(c AS DOUBLE))+bitwise_convert_double_to_long_bits(cast(c AS DOUBLE))) IS NULL);
++----------------------+
+| col                  |
++----------------------+
+| -9223372036854775808 |
+| -9223372036854775808 |
+| -9223372036854775808 |
+|  9214364837600034816 |
+|  9214364837600034816 |
+|  9214364837600034816 |
+|                      |
+|                      |
+|                      |
++----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B26_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(cast(c AS DOUBLE)+cast(c AS DOUBLE)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (bitwise_convert_double_to_long_bits(cast(c AS DOUBLE)+cast(c AS DOUBLE))>0
+       OR bitwise_convert_double_to_long_bits(cast(c AS DOUBLE)+cast(c AS DOUBLE))<0
+       OR bitwise_convert_double_to_long_bits(cast(c AS DOUBLE)+cast(c AS DOUBLE)) IS NULL);
++---------------------+
+| col                 |
++---------------------+
+| 4611686018427387904 |
+| 4611686018427387904 |
+| 4611686018427387904 |
+| 4616189618054758400 |
+| 4616189618054758400 |
+| 4616189618054758400 |
+|                     |
+|                     |
+|                     |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B26_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(cast(c AS DOUBLE))+bitwise_convert_double_to_long_bits(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((bitwise_convert_double_to_long_bits(cast(c AS DOUBLE))+bitwise_convert_double_to_long_bits(s_int))>0
+       OR (bitwise_convert_double_to_long_bits(cast(c AS DOUBLE))+bitwise_convert_double_to_long_bits(s_int))<0
+       OR (bitwise_convert_double_to_long_bits(cast(c AS DOUBLE))+bitwise_convert_double_to_long_bits(s_int)) IS NULL);
++----------------------+
+| col                  |
++----------------------+
+| -9223372036854775808 |
+|  9214364837600034816 |
+|  9218868437227405312 |
+|  9218868437227405312 |
+|                      |
+|                      |
+|                      |
+|                      |
+|                      |
++----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B26_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(cast(c AS DOUBLE)+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (bitwise_convert_double_to_long_bits(cast(c AS DOUBLE)+s_int)>0
+       OR bitwise_convert_double_to_long_bits(cast(c AS DOUBLE)+s_int)<0
+       OR bitwise_convert_double_to_long_bits(cast(c AS DOUBLE)+s_int) IS NULL);
++---------------------+
+| col                 |
++---------------------+
+| 4611686018427387904 |
+| 4613937818241073152 |
+| 4613937818241073152 |
+| 4616189618054758400 |
+|                     |
+|                     |
+|                     |
+|                     |
+|                     |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B27_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT bitwise_convert_long_bits_to_double(c)+bitwise_convert_long_bits_to_double(c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE (s_int IN (0,
+                    1,
+                    2)
+          OR s_int IS NULL)
+     AND ((bitwise_convert_long_bits_to_double(c)+bitwise_convert_long_bits_to_double(c))<99999
+          OR (bitwise_convert_long_bits_to_double(c)+bitwise_convert_long_bits_to_double(c)) IS NULL));
++--------+
+| EXPR$0 |
++--------+
+|      9 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B27_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT bitwise_convert_long_bits_to_double(c+c) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE (s_int IN (0,
+                    1,
+                    2)
+          OR s_int IS NULL)
+     AND (bitwise_convert_long_bits_to_double(c+c)<99999
+          OR bitwise_convert_long_bits_to_double(c+c) IS NULL));
++--------+
+| EXPR$0 |
++--------+
+|      9 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B27_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT bitwise_convert_long_bits_to_double(c)+bitwise_convert_long_bits_to_double(s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE (s_int IN (0,
+                    1,
+                    2)
+          OR s_int IS NULL)
+     AND ((bitwise_convert_long_bits_to_double(c)+bitwise_convert_long_bits_to_double(s_int))<99999
+          OR (bitwise_convert_long_bits_to_double(c)+bitwise_convert_long_bits_to_double(s_int)) IS NULL));
++--------+
+| EXPR$0 |
++--------+
+|      9 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B27_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT bitwise_convert_long_bits_to_double(c+s_int) AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE (s_int IN (0,
+                    1,
+                    2)
+          OR s_int IS NULL)
+     AND (bitwise_convert_long_bits_to_double(c+s_int)<99999
+          OR bitwise_convert_long_bits_to_double(c+s_int) IS NULL));
++--------+
+| EXPR$0 |
++--------+
+|      9 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B28_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(c, 1)+bitwise_or(c, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((bitwise_or(c, 1)+bitwise_or(c, 1))<99999
+       OR (bitwise_or(c, 1)+bitwise_or(c, 1)) IS NULL);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   6 |
+|   6 |
+|   6 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B28_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(c, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (bitwise_or(c, c)<99999
+       OR bitwise_or(c, c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B28_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(c, 1)+bitwise_or(s_int, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((bitwise_or(c, 1)+bitwise_or(s_int, 1))<99999
+       OR (bitwise_or(c, 1)+bitwise_or(s_int, 1)) IS NULL);
++-----+
+| col |
++-----+
+|   2 |
+|   4 |
+|   4 |
+|   6 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B28_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (bitwise_or(c, s_int)<99999
+       OR bitwise_or(c, s_int) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|   3 |
+|   3 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B29_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(c, 1)+bitwise_shift_left(c, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((bitwise_shift_left(c, 1)+bitwise_shift_left(c, 1))<99999
+       OR (bitwise_shift_left(c, 1)+bitwise_shift_left(c, 1)) IS NULL);
++-----+
+| col |
++-----+
+|   4 |
+|   4 |
+|   4 |
+|   8 |
+|   8 |
+|   8 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B29_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(c, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (bitwise_shift_left(c, c)<99999
+       OR bitwise_shift_left(c, c) IS NULL);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   8 |
+|   8 |
+|   8 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B29_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(c, 1)+bitwise_shift_left(s_int, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((bitwise_shift_left(c, 1)+bitwise_shift_left(s_int, 1))<99999
+       OR (bitwise_shift_left(c, 1)+bitwise_shift_left(s_int, 1)) IS NULL);
++-----+
+| col |
++-----+
+|   4 |
+|   6 |
+|   6 |
+|   8 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B29_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (bitwise_shift_left(c, s_int)<99999
+       OR bitwise_shift_left(c, s_int) IS NULL);
++-----+
+| col |
++-----+
+|   2 |
+|   4 |
+|   4 |
+|   8 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B30_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(c, 1)+bitwise_shift_right(c, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((bitwise_shift_right(c, 1)+bitwise_shift_right(c, 1))<99999
+       OR (bitwise_shift_right(c, 1)+bitwise_shift_right(c, 1)) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B30_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(c, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (bitwise_shift_right(c, c)<99999
+       OR bitwise_shift_right(c, c) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B30_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(c, 1)+bitwise_shift_right(s_int, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((bitwise_shift_right(c, 1)+bitwise_shift_right(s_int, 1))<99999
+       OR (bitwise_shift_right(c, 1)+bitwise_shift_right(s_int, 1)) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   1 |
+|   2 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B30_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (bitwise_shift_right(c, s_int)<99999
+       OR bitwise_shift_right(c, s_int) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   1 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B31_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(c, 1)+bitwise_xor(c, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((bitwise_xor(c, 1)+bitwise_xor(c, 1))<99999
+       OR (bitwise_xor(c, 1)+bitwise_xor(c, 1)) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   6 |
+|   6 |
+|   6 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B31_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(c, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (bitwise_xor(c, c)<99999
+       OR bitwise_xor(c, c) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B31_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(c, 1)+bitwise_xor(s_int, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((bitwise_xor(c, 1)+bitwise_xor(s_int, 1))<99999
+       OR (bitwise_xor(c, 1)+bitwise_xor(s_int, 1)) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   3 |
+|   3 |
+|   6 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B31_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (bitwise_xor(c, s_int)<99999
+       OR bitwise_xor(c, s_int) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   3 |
+|   3 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B33_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(c)+human_readable_binary_byte_format(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((human_readable_binary_byte_format(c)+human_readable_binary_byte_format(c))<'99999'
+       OR (human_readable_binary_byte_format(c)+human_readable_binary_byte_format(c)) IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B33_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (human_readable_binary_byte_format(c+c)<'99999'
+       OR human_readable_binary_byte_format(c+c) IS NULL);
++-----+
+| col |
++-----+
+| 2 B |
+| 2 B |
+| 2 B |
+| 4 B |
+| 4 B |
+| 4 B |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B33_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(c)+human_readable_binary_byte_format(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((human_readable_binary_byte_format(c)+human_readable_binary_byte_format(s_int))<'99999'
+       OR (human_readable_binary_byte_format(c)+human_readable_binary_byte_format(s_int)) IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B33_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (human_readable_binary_byte_format(c+s_int)<'99999'
+       OR human_readable_binary_byte_format(c+s_int) IS NULL);
++-----+
+| col |
++-----+
+| 2 B |
+| 3 B |
+| 3 B |
+| 4 B |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B34_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(c)+human_readable_decimal_byte_format(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((human_readable_decimal_byte_format(c)+human_readable_decimal_byte_format(c))<'99999'
+       OR (human_readable_decimal_byte_format(c)+human_readable_decimal_byte_format(c)) IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B34_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (human_readable_decimal_byte_format(c+c)<'99999'
+       OR human_readable_decimal_byte_format(c+c) IS NULL);
++-----+
+| col |
++-----+
+| 2 B |
+| 2 B |
+| 2 B |
+| 4 B |
+| 4 B |
+| 4 B |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B34_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(c)+human_readable_decimal_byte_format(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((human_readable_decimal_byte_format(c)+human_readable_decimal_byte_format(s_int))<'99999'
+       OR (human_readable_decimal_byte_format(c)+human_readable_decimal_byte_format(s_int)) IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B34_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (human_readable_decimal_byte_format(c+s_int)<'99999'
+       OR human_readable_decimal_byte_format(c+s_int) IS NULL);
++-----+
+| col |
++-----+
+| 2 B |
+| 3 B |
+| 3 B |
+| 4 B |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B35_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(c)+human_readable_decimal_format(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((human_readable_decimal_format(c)+human_readable_decimal_format(c))<99999
+       OR (human_readable_decimal_format(c)+human_readable_decimal_format(c)) IS NULL);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B35_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(c+c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (human_readable_decimal_format(c+c)<99999
+       OR human_readable_decimal_format(c+c) IS NULL);
++-----+
+| col |
++-----+
+| 2   |
+| 2   |
+| 2   |
+| 4   |
+| 4   |
+| 4   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B35_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(c)+human_readable_decimal_format(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((human_readable_decimal_format(c)+human_readable_decimal_format(s_int))<99999
+       OR (human_readable_decimal_format(c)+human_readable_decimal_format(s_int)) IS NULL);
++-----+
+| col |
++-----+
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B35_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(c+s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (human_readable_decimal_format(c+s_int)<99999
+       OR human_readable_decimal_format(c+s_int) IS NULL);
++-----+
+| col |
++-----+
+| 2   |
+| 3   |
+| 3   |
+| 4   |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B36_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(c, 0)+safe_divide(c, 0) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((safe_divide(c, 0)+safe_divide(c, 0))<99999
+       OR (safe_divide(c, 0)+safe_divide(c, 0)) IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B36_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(c, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (safe_divide(c, c)<99999
+       OR safe_divide(c, c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B36_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(c, 0)+safe_divide(s_int, 0) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((safe_divide(c, 0)+safe_divide(s_int, 0))<99999
+       OR (safe_divide(c, 0)+safe_divide(s_int, 0)) IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B36_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (safe_divide(c, s_int)<99999
+       OR safe_divide(c, s_int) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   1 |
+|   2 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B1_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(c, c)||concat(c, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((concat(c, c)||concat(c, c))<'99999'
+       OR (concat(c, c)||concat(c, c)) IS NULL);
++------+
+| col  |
++------+
+| 1111 |
+| 1111 |
+| 1111 |
+| 2222 |
+| 2222 |
+| 2222 |
+|      |
+|      |
+|      |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B1_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(c, s_int)||concat(c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((concat(c, s_int)||concat(c, s_int))<'99999'
+       OR (concat(c, s_int)||concat(c, s_int)) IS NULL);
++------+
+| col  |
++------+
+| 1111 |
+| 1212 |
+| 2121 |
+| 2222 |
+|      |
+|      |
+|      |
+|      |
+|      |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B2_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(cast(c AS char), cast(c AS char))||textcat(cast(c AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((textcat(cast(c AS char), cast(c AS char))||textcat(cast(c AS char), cast(c AS char)))<'99999'
+       OR (textcat(cast(c AS char), cast(c AS char))||textcat(cast(c AS char), cast(c AS char))) IS NULL);
++------+
+| col  |
++------+
+| 1111 |
+| 1111 |
+| 1111 |
+| 2222 |
+| 2222 |
+| 2222 |
+|      |
+|      |
+|      |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B2_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(cast(c AS char), cast(s_int AS char))||textcat(cast(c AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((textcat(cast(c AS char), cast(s_int AS char))||textcat(cast(c AS char), cast(s_int AS char)))<'99999'
+       OR (textcat(cast(c AS char), cast(s_int AS char))||textcat(cast(c AS char), cast(s_int AS char))) IS NULL);
++------+
+| col  |
++------+
+| 1111 |
+| 1212 |
+| 2121 |
+| 2222 |
+|      |
+|      |
+|      |
+|      |
+|      |
++------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B3_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_format('%sZ', c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (string_format('%sZ', c)<'0'
+       OR string_format('%sZ', c)>'0'
+       OR string_format('%sZ', c) IS NULL);
++-------+
+| col   |
++-------+
+| 1Z    |
+| 1Z    |
+| 1Z    |
+| 2Z    |
+| 2Z    |
+| 2Z    |
+| nullZ |
+| nullZ |
+| nullZ |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B3_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_format('%sZ', s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (string_format('%sZ', s_int)<'0'
+       OR string_format('%sZ', s_int)>'0'
+       OR string_format('%sZ', s_int) IS NULL);
++-------+
+| col   |
++-------+
+| 1Z    |
+| 1Z    |
+| 1Z    |
+| 2Z    |
+| 2Z    |
+| 2Z    |
+| nullZ |
+| nullZ |
+| nullZ |
++-------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B4_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (length(c)<99999
+       OR length(c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B4_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (length(s_int)<99999
+       OR length(s_int) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B5_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (char_length(c)<99999
+       OR char_length(c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B5_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (char_length(s_int)<99999
+       OR char_length(s_int) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B6_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (character_length(c)<99999
+       OR character_length(c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B6_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (character_length(s_int)<99999
+       OR character_length(s_int) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B7_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (strlen(c)<99999
+       OR strlen(c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B7_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (strlen(s_int)<99999
+       OR strlen(s_int) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B8_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (lower(c)<'99999'
+       OR lower(c) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B8_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (lower(s_int)<'99999'
+       OR lower(s_int) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B9_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (upper(c)<'99999'
+       OR upper(c) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B9_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (upper(s_int)<'99999'
+       OR upper(s_int) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B10_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (parse_long(cast(c AS char))<99999
+       OR parse_long(cast(c AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B10_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (parse_long(cast(s_int AS char))<99999
+       OR parse_long(cast(s_int AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B11_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position(c IN c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (position(c IN c)<99999
+       OR position(c IN c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B11_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position(s_int IN c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (position(s_int IN c)<99999
+       OR position(s_int IN c) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B11_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position(c IN s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (position(c IN s_int)<99999
+       OR position(c IN s_int) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B11_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position(s_int IN s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (position(s_int IN s_int)<99999
+       OR position(s_int IN s_int) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B12_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(cast(c AS char), '.*') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (regexp_extract(cast(c AS char), '.*')<'99999'
+       OR regexp_extract(cast(c AS char), '.*') IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B12_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(cast(s_int AS char), '.*') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (regexp_extract(cast(s_int AS char), '.*')<99999
+       OR regexp_extract(cast(s_int AS char), '.*') IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B13_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(cast(c AS char), '.*') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (regexp_like(cast(c AS char), '.*') IS TRUE
+       OR regexp_like(cast(c AS char), '.*') IS FALSE);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B13_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(cast(s_int AS char), '.*') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (regexp_like(cast(s_int AS char), '.*') IS TRUE
+       OR regexp_like(cast(s_int AS char), '.*') IS FALSE);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B14_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(cast(c AS char), '1') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (contains_string(cast(c AS char), '1') IS TRUE
+       OR contains_string(cast(c AS char), '1') IS FALSE);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
++-------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B14_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(cast(s_int AS char), '1') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (contains_string(cast(s_int AS char), '1') IS TRUE
+       OR contains_string(cast(s_int AS char), '1') IS FALSE);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
++-------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B15_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(cast(c AS char), '1') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (icontains_string(cast(c AS char), '1') IS TRUE
+       OR icontains_string(cast(c AS char), '1') IS FALSE);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
++-------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B15_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(cast(s_int AS char), '1') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (icontains_string(cast(s_int AS char), '1') IS TRUE
+       OR icontains_string(cast(s_int AS char), '1') IS FALSE);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
++-------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B16_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(c, '1', 'Z') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (replace(c, '1', 'Z')<'0'
+       OR replace(c, '1', 'Z')>'0'
+       OR replace(c, '1', 'Z') IS NULL);
++-----+
+| col |
++-----+
+| 2   |
+| 2   |
+| 2   |
+| Z   |
+| Z   |
+| Z   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B16_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(s_int, '1', 'Z') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (replace(s_int, '1', 'Z')<'0'
+       OR replace(s_int, '1', 'Z')>'0'
+       OR replace(s_int, '1', 'Z') IS NULL);
++-----+
+| col |
++-----+
+| 2   |
+| 2   |
+| 2   |
+| Z   |
+| Z   |
+| Z   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B17_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(cast(c AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (strpos(cast(c AS char), cast(c AS char))<99999
+       OR strpos(cast(c AS char), cast(c AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B17_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(cast(s_int AS char), cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (strpos(cast(s_int AS char), cast(c AS char))<99999
+       OR strpos(cast(s_int AS char), cast(c AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B17_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(cast(c AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (strpos(cast(c AS char), cast(s_int AS char))<99999
+       OR strpos(cast(c AS char), cast(s_int AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B17_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(cast(s_int AS char), cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (strpos(cast(s_int AS char), cast(s_int AS char))<99999
+       OR strpos(cast(s_int AS char), cast(s_int AS char)) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B18_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(cast(c AS char), 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (substring(cast(c AS char), 1)<'99999'
+       OR substring(cast(c AS char), 1) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B18_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(cast(s_int AS char), 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (substring(cast(s_int AS char), 1)<'99999'
+       OR substring(cast(s_int AS char), 1) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B19_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(cast(c AS char), 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (right(cast(c AS char), 1)<'99999'
+       OR right(cast(c AS char), 1) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B19_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(cast(s_int AS char), 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (right(cast(s_int AS char), 1)<'99999'
+       OR right(cast(s_int AS char), 1) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B20_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(cast(c AS char), 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (left(cast(c AS char), 1)<'99999'
+       OR left(cast(c AS char), 1) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B20_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(cast(s_int AS char), 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (left(cast(s_int AS char), 1)<'99999'
+       OR left(cast(s_int AS char), 1) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B21_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(cast(c AS char), 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (substr(cast(c AS char), 1)<'99999'
+       OR substr(cast(c AS char), 1) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B21_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(cast(s_int AS char), 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (substr(cast(s_int AS char), 1)<'99999'
+       OR substr(cast(s_int AS char), 1) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B22_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH '1'
+            FROM c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (trim(BOTH '1'
+            FROM c)<'99999'
+       OR trim(BOTH '1'
+               FROM c) IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B22_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH '1'
+            FROM s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (trim(BOTH '1'
+            FROM s_int)<'99999'
+       OR trim(BOTH '1'
+               FROM s_int) IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B23_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(cast(c AS char), '1') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (btrim(cast(c AS char), '1')<'99999'
+       OR btrim(cast(c AS char), '1') IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B23_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(cast(s_int AS char), '1') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (btrim(cast(s_int AS char), '1')<'99999'
+       OR btrim(cast(s_int AS char), '1') IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B24_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(cast(c AS char), '1') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (ltrim(cast(c AS char), '1')<'99999'
+       OR ltrim(cast(c AS char), '1') IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B24_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(cast(s_int AS char), '1') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (ltrim(cast(s_int AS char), '1')<'99999'
+       OR ltrim(cast(s_int AS char), '1') IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B25_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(cast(c AS char), '1') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (rtrim(cast(c AS char), '1')<'99999'
+       OR rtrim(cast(c AS char), '1') IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B25_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(cast(s_int AS char), '1') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (rtrim(cast(s_int AS char), '1')<'99999'
+       OR rtrim(cast(s_int AS char), '1') IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B26_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(cast(c AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (reverse(cast(c AS char))<'99999'
+       OR reverse(cast(c AS char)) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B26_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(cast(s_int AS char)) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (reverse(cast(s_int AS char))<'99999'
+       OR reverse(cast(s_int AS char)) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B27_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(cast(c AS char), 2) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (repeat(cast(c AS char), 2)<'99999'
+       OR repeat(cast(c AS char), 2) IS NULL);
++-----+
+| col |
++-----+
+| 11  |
+| 11  |
+| 11  |
+| 22  |
+| 22  |
+| 22  |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B27_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(cast(s_int AS char), 2) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (repeat(cast(s_int AS char), 2)<'99999'
+       OR repeat(cast(s_int AS char), 2) IS NULL);
++-----+
+| col |
++-----+
+| 11  |
+| 11  |
+| 11  |
+| 22  |
+| 22  |
+| 22  |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B28_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(cast(c AS char), 3, 'Z') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (lpad(cast(c AS char), 3, 'Z')<'0'
+       OR lpad(cast(c AS char), 3, 'Z')>'0'
+       OR lpad(cast(c AS char), 3, 'Z') IS NULL);
++-----+
+| col |
++-----+
+| ZZ1 |
+| ZZ1 |
+| ZZ1 |
+| ZZ2 |
+| ZZ2 |
+| ZZ2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B28_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(cast(s_int AS char), 3, 'Z') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (lpad(cast(s_int AS char), 3, 'Z')<'0'
+       OR lpad(cast(s_int AS char), 3, 'Z')>'0'
+       OR lpad(cast(s_int AS char), 3, 'Z') IS NULL);
++-----+
+| col |
++-----+
+| ZZ1 |
+| ZZ1 |
+| ZZ1 |
+| ZZ2 |
+| ZZ2 |
+| ZZ2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B29_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(cast(c AS char), 3, 'Z') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (rpad(cast(c AS char), 3, 'Z')<'0'
+       OR rpad(cast(c AS char), 3, 'Z')>'0'
+       OR rpad(cast(c AS char), 3, 'Z') IS NULL);
++-----+
+| col |
++-----+
+| 1ZZ |
+| 1ZZ |
+| 1ZZ |
+| 2ZZ |
+| 2ZZ |
+| 2ZZ |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B29_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(cast(s_int AS char), 3, 'Z') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (rpad(cast(s_int AS char), 3, 'Z')<'0'
+       OR rpad(cast(s_int AS char), 3, 'Z')>'0'
+       OR rpad(cast(s_int AS char), 3, 'Z') IS NULL);
++-----+
+| col |
++-----+
+| 1ZZ |
+| 1ZZ |
+| 1ZZ |
+| 2ZZ |
+| 2ZZ |
+| 2ZZ |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B1_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT CURRENT_TIMESTAMP AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE (s_int IN (0,
+                    1,
+                    2)
+          OR s_int IS NULL)
+     AND (CURRENT_TIMESTAMP IS NOT NULL));
++--------+
+| EXPR$0 |
++--------+
+|      9 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B2_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT CURRENT_DATE AS col
+   FROM test_unnest,
+        unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+   WHERE (s_int IN (0,
+                    1,
+                    2)
+          OR s_int IS NULL)
+     AND (CURRENT_DATE IS NOT NULL));
++--------+
+| EXPR$0 |
++--------+
+|      9 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B3_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (date_trunc('year', c) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B3_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (date_trunc('year', s_int) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B4_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(c, 'P1D') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (time_ceil(c, 'P1D') IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B4_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(s_int, 'P1D') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (time_ceil(s_int, 'P1D') IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B5_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(c, 'P1D') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (time_floor(c, 'P1D') IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B5_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(s_int, 'P1D') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (time_floor(s_int, 'P1D') IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B6_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(c, 'P1D', 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (time_shift(c, 'P1D', 1) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B6_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(s_int, 'P1D', 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (time_shift(s_int, 'P1D', 1) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B7_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(c, 'HOUR') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (time_extract(c, 'HOUR') IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B7_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(s_int, 'HOUR') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (time_extract(s_int, 'HOUR') IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B8_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (time_parse(c) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B8_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (time_parse(s_int) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B9_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(c, '2001-01-01/P1D') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (time_in_interval(c, '2001-01-01/P1D') IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B9_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(s_int, '2001-01-01/P1D') AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (time_in_interval(c, '2001-01-01/P1D') IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B10_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (millis_to_timestamp(c)<>'2000-01-01T00:00:00.000Z');
++-------------------------+
+| col                     |
++-------------------------+
+| 1970-01-01 00:00:00.001 |
+| 1970-01-01 00:00:00.001 |
+| 1970-01-01 00:00:00.001 |
+| 1970-01-01 00:00:00.002 |
+| 1970-01-01 00:00:00.002 |
+| 1970-01-01 00:00:00.002 |
++-------------------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B10_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (millis_to_timestamp(s_int)<>'2000-01-01T00:00:00.000Z');
++-------------------------+
+| col                     |
++-------------------------+
+| 1970-01-01 00:00:00.001 |
+| 1970-01-01 00:00:00.001 |
+| 1970-01-01 00:00:00.001 |
+| 1970-01-01 00:00:00.002 |
+| 1970-01-01 00:00:00.002 |
+| 1970-01-01 00:00:00.002 |
++-------------------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B11_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (timestamp_to_millis(c) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B11_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (timestamp_to_millis(s_int) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B12_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (extract(DAY
+               FROM c) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B12_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (extract(DAY
+               FROM s_int) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B13_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(c TO DAY) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (floor(c TO DAY) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B13_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(s_int TO DAY) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (floor(s_int TO DAY) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B14_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(c TO DAY) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (ceil(c TO DAY) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B14_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(s_int TO DAY) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (ceil(s_int TO DAY) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B15_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (timestampadd(DAY, 1, c) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B15_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (timestampadd(DAY, 1, s_int) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B16_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, c, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (timestampdiff(DAY, c, c) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B16_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, s_int, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (timestampdiff(DAY, s_int, c) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B16_C3_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (timestampdiff(DAY, c, s_int) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B16_C4_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, s_int, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (timestampdiff(DAY, s_int, s_int) IS NOT NULL);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_reduction_funcs TEST_ID: A1_B1_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(c, c, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (greatest(c, c, 1)<99999
+       OR greatest(c, c, 1) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_reduction_funcs TEST_ID: A1_B1_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(c, s_int, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (greatest(c, s_int, 1)<99999
+       OR greatest(c, s_int, 1) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_reduction_funcs TEST_ID: A1_B2_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(c, c, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (least(c, c, 1)<99999
+       OR least(c, c, 1) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_reduction_funcs TEST_ID: A1_B2_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(c, s_int, 1) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (least(c, s_int, 1)<99999
+       OR least(c, s_int, 1) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_ipaddr_funcs TEST_ID: A1_B1_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ip4_match(c, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (ip4_match(c, c) IS NOT NULL);
+No match found
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_ipaddr_funcs TEST_ID: A1_B1_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ip4_match(c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (ip4_match(c, s_int) IS TRUE);
+No match found
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_ipaddr_funcs TEST_ID: A1_B2_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ip4_parse(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (ip4_parse(c) IS NOT NULL);
+No match found
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_ipaddr_funcs TEST_ID: A1_B2_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ip4_parse(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (ip4_parse(s_int) IS NOT NULL);
+No match found
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_ipaddr_funcs TEST_ID: A1_B3_C1_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ip4_stringify(c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (ip4_stringify(c) IS NOT NULL);
+No match found
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_ipaddr_funcs TEST_ID: A1_B3_C2_D2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ip4_stringify(s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (ip4_stringify(s_int) IS NOT NULL);
+No match found
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B1_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(c AS char) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (cast(c AS char)<99999
+       OR cast(c AS char) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B1_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(s_int AS char) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (cast(s_int AS char)<99999
+       OR cast(s_int AS char) IS NULL);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B2_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE c
+            WHEN 1 THEN 6
+            ELSE 7
+        END) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((CASE c
+            WHEN 1 THEN 6
+            ELSE 7
+        END)<99999
+       OR (CASE c
+               WHEN 1 THEN 6
+               ELSE 7
+           END) IS NULL);
++-----+
+| col |
++-----+
+|   6 |
+|   6 |
+|   6 |
+|   7 |
+|   7 |
+|   7 |
+|   7 |
+|   7 |
+|   7 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B2_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE s_int
+            WHEN 1 THEN 8
+            ELSE 9
+        END) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((CASE s_int
+            WHEN 1 THEN 8
+            ELSE 9
+        END)<99999
+       OR (CASE s_int
+               WHEN 1 THEN 8
+               ELSE 9
+           END) IS NULL);
++-----+
+| col |
++-----+
+|   8 |
+|   8 |
+|   8 |
+|   9 |
+|   9 |
+|   9 |
+|   9 |
+|   9 |
+|   9 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B3_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN c=1 THEN 6
+            ELSE 7
+        END) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((CASE
+            WHEN c=1 THEN 6
+            ELSE 7
+        END)<99999
+       OR (CASE
+               WHEN c=1 THEN 6
+               ELSE 7
+           END) IS NULL);
++-----+
+| col |
++-----+
+|   6 |
+|   6 |
+|   6 |
+|   7 |
+|   7 |
+|   7 |
+|   7 |
+|   7 |
+|   7 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B3_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN s_int=1 THEN 8
+            ELSE 9
+        END) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND ((CASE
+            WHEN s_int=1 THEN 8
+            ELSE 9
+        END)<99999
+       OR (CASE
+               WHEN s_int=1 THEN 8
+               ELSE 9
+           END) IS NULL);
++-----+
+| col |
++-----+
+|   8 |
+|   8 |
+|   8 |
+|   9 |
+|   9 |
+|   9 |
+|   9 |
+|   9 |
+|   9 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B4_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(c, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (nullif(c, c)<99999
+       OR nullif(c, c) IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B4_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (nullif(c, s_int)<99999
+       OR nullif(c, s_int) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B4_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(s_int, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (nullif(s_int, c)<99999
+       OR nullif(s_int, c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B4_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(s_int, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (nullif(s_int, s_int)<99999
+       OR nullif(s_int, s_int) IS NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B5_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(c, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (coalesce(c, c)<99999
+       OR coalesce(c, c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B5_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (coalesce(c, s_int)<99999
+       OR coalesce(c, s_int) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B5_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(s_int, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (coalesce(s_int, c)<99999
+       OR coalesce(s_int, c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B5_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(s_int, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (coalesce(s_int, s_int)<99999
+       OR coalesce(s_int, s_int) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B6_C1_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(c, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (nvl(c, c)<99999
+       OR nvl(c, c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B6_C2_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(c, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (nvl(c, s_int)<99999
+       OR nvl(c, s_int) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B6_C3_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(s_int, c) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (nvl(s_int, c)<99999
+       OR nvl(s_int, c) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B6_C4_D2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(s_int, s_int) AS col
+FROM test_unnest,
+     unnest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS u(c)
+WHERE (s_int IN (0,
+                 1,
+                 2)
+       OR s_int IS NULL)
+  AND (nvl(s_int, s_int)<99999
+       OR nvl(s_int, s_int) IS NULL);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|     |
+|     |
+|     |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 261 Positive tests: 227 Negative tests: 34
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql.iq
new file mode 100644
index 000000000000..e13cd4d38fae
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql.iq
@@ -0,0 +1,21585 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaUnnest/mv&numMergeBuffers=3
+!set outputformat mysql
+SELECT *
+FROM test_unnest;
++-------------------------+-------+--------+---------+----------+------------------------------------------------+------------------------+--------------------------------------+----------------------------------+--------------------------------------+----------------------------------+-----------------------------+
+| __time                  | c_str | c_long | c_float | c_double | c_mv_complex                                   | c_mv_num               | c_mv_complex_with_null_and_empty_val | c_mv_num_with_null_and_empty_val | c_mv_complex_with_null_and_empty_row | c_mv_num_with_null_and_empty_row | c_mv_all_null_and_empty_val |
++-------------------------+-------+--------+---------+----------+------------------------------------------------+------------------------+--------------------------------------+----------------------------------+--------------------------------------+----------------------------------+-----------------------------+
+| 2022-01-01 00:00:00.000 |       |      1 |     0.1 |      0.1 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 | str2  |      2 |     0.2 |      0.2 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 | str3  |      3 |     0.3 |      0.3 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 | str4  |      4 |     0.4 |      0.4 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 |       |      0 |     0.0 |      0.0 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      |
++-------------------------+-------+--------+---------+----------+------------------------------------------------+------------------------+--------------------------------------+----------------------------------+--------------------------------------+----------------------------------+-----------------------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(doesnt_exist) AS u(c);
+not found
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(doesnt_exist) AS u(c)
+GROUP BY c;
+not found
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(doesnt_exist)) AS u(c);
+not found
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(doesnt_exist)) AS u(c)
+GROUP BY c;
+not found
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT *
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c_mv_complex);
+is ambiguous
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT *
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c_mv_complex)
+GROUP BY c;
+is ambiguous
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str0
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c_str);
+not found in any table
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT u.c_str
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c_str);
++-------------+
+| c_str       |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c_str));
++--------+
+| EXPR$0 |
++--------+
+|     25 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str0
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c_str));
++-------------+
+| c_str0      |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B11 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT u.c_str
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c_str));
+not found
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B12 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str0,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c_str)
+GROUP BY c_str0;
+not found in any table
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT u.c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c_str)
+GROUP BY u.c_str;
++-------------+-----+
+| c_str       | cnt |
++-------------+-----+
+| 1           |   5 |
+| [2]         |   5 |
+| [3, [4, 5]] |   5 |
+| my_empty    |   5 |
+| my_null     |   5 |
++-------------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B14 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     strlen(unnest(mv_to_array(c_mv_complex))) AS u(c);
+ParseException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     strlen(unnest(mv_to_array(c_mv_complex))) AS u(c)
+GROUP BY c;
+ParseException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex || 'STR')) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B17 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex || 'STR')) AS u(c)
+GROUP BY c;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B18 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(mv_concat(c_mv_complex, c_mv_complex))) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B19 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(mv_concat(c_mv_complex, c_mv_complex))) AS u(c)
+GROUP BY c;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c || 'STR') col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c);
++----------------+
+| col            |
++----------------+
+| 1STR           |
+| 1STR           |
+| 1STR           |
+| 1STR           |
+| 1STR           |
+| [2]STR         |
+| [2]STR         |
+| [2]STR         |
+| [2]STR         |
+| [2]STR         |
+| [3, [4, 5]]STR |
+| [3, [4, 5]]STR |
+| [3, [4, 5]]STR |
+| [3, [4, 5]]STR |
+| [3, [4, 5]]STR |
+| my_emptySTR    |
+| my_emptySTR    |
+| my_emptySTR    |
+| my_emptySTR    |
+| my_emptySTR    |
+| my_nullSTR     |
+| my_nullSTR     |
+| my_nullSTR     |
+| my_nullSTR     |
+| my_nullSTR     |
++----------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c || 'STR') col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY c;
++----------------+
+| col            |
++----------------+
+| 1STR           |
+| [2]STR         |
+| [3, [4, 5]]STR |
+| my_emptySTR    |
+| my_nullSTR     |
++----------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(c) col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|  11 |
+|  11 |
+|  11 |
+|  11 |
+|  11 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   7 |
+|   7 |
+|   7 |
+|   7 |
+|   7 |
+|   8 |
+|   8 |
+|   8 |
+|   8 |
+|   8 |
++-----+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(c) col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY c;
++-----+
+| col |
++-----+
+|   1 |
+|  11 |
+|   3 |
+|   7 |
+|   8 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(c || 'STR') col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c);
++-----+
+| col |
++-----+
+|  10 |
+|  10 |
+|  10 |
+|  10 |
+|  10 |
+|  11 |
+|  11 |
+|  11 |
+|  11 |
+|  11 |
+|  14 |
+|  14 |
+|  14 |
+|  14 |
+|  14 |
+|   4 |
+|   4 |
+|   4 |
+|   4 |
+|   4 |
+|   6 |
+|   6 |
+|   6 |
+|   6 |
+|   6 |
++-----+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(c || 'STR') col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY c;
++-----+
+| col |
++-----+
+|  10 |
+|  11 |
+|  14 |
+|   4 |
+|   6 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(c || c) col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c);
++-----+
+| col |
++-----+
+|  14 |
+|  14 |
+|  14 |
+|  14 |
+|  14 |
+|  16 |
+|  16 |
+|  16 |
+|  16 |
+|  16 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|  22 |
+|  22 |
+|  22 |
+|  22 |
+|  22 |
+|   6 |
+|   6 |
+|   6 |
+|   6 |
+|   6 |
++-----+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(c || c) col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY c;
++-----+
+| col |
++-----+
+|  14 |
+|  16 |
+|   2 |
+|  22 |
+|   6 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B28 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       c_mv_complex AS new_col
+FROM test_unnest,
+     unnest(mv_to_array(new_col)) AS u(c);
+not found in any table
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c_mv_complex AS new_col
+   FROM test_unnest) t1,
+     unnest(mv_to_array(new_col)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_general TEST_ID: A1_B30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c AS new_col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| new_col     |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_str) AS u(c);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_str) AS u(c)
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_long) AS u(c);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_long) AS u(c)
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_float) AS u(c);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_float) AS u(c)
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_double) AS u(c);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_double) AS u(c)
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_mv_complex) AS u(c);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_mv_complex) AS u(c)
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_mv_num) AS u(c);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_mv_num) AS u(c)
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_mv_complex_with_null_and_empty_val) AS u(c);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_mv_complex_with_null_and_empty_val) AS u(c)
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_mv_num_with_null_and_empty_val) AS u(c);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_mv_num_with_null_and_empty_val) AS u(c)
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_mv_complex_with_null_and_empty_row) AS u(c);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_mv_complex_with_null_and_empty_row) AS u(c)
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_mv_num_with_null_and_empty_row) AS u(c);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_mv_num_with_null_and_empty_row) AS u(c)
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_mv_all_null_and_empty_val) AS u(c);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A1_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(c_mv_all_null_and_empty_val) AS u(c)
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A2_B1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_append(c_mv_complex, 'Z')) AS u(c);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A2_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_append(c_mv_complex, 'Z')) AS u(c)
+GROUP BY c;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A3_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A3_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY c;
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A4_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY c;
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A5_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY c;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A6_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A7_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY c;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A8_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A8_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A9_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_col_datatype_mv TEST_ID: A9_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+|   |
+|   |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(25 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "unnest",
+    "base" : {
+      "type" : "table",
+      "name" : "test_unnest"
+    },
+    "virtualColumn" : {
+      "type" : "expression",
+      "name" : "j0.unnest",
+      "expression" : "\"c_mv_complex\"",
+      "outputType" : "STRING"
+    },
+    "unnestFilter" : null
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "resultFormat" : "compactedList",
+  "columns" : [ "j0.unnest" ],
+  "columnTypes" : [ "STRING" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A1_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT *
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c));
++-------------------------+-------+--------+---------+----------+------------------------------------------------+------------------------+--------------------------------------+----------------------------------+--------------------------------------+----------------------------------+-----------------------------+-------------+
+| __time                  | c_str | c_long | c_float | c_double | c_mv_complex                                   | c_mv_num               | c_mv_complex_with_null_and_empty_val | c_mv_num_with_null_and_empty_val | c_mv_complex_with_null_and_empty_row | c_mv_num_with_null_and_empty_row | c_mv_all_null_and_empty_val | c           |
++-------------------------+-------+--------+---------+----------+------------------------------------------------+------------------------+--------------------------------------+----------------------------------+--------------------------------------+----------------------------------+-----------------------------+-------------+
+| 2022-01-01 00:00:00.000 |       |      1 |     0.1 |      0.1 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      | 1           |
+| 2022-01-01 00:00:00.000 |       |      1 |     0.1 |      0.1 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      | [2]         |
+| 2022-01-01 00:00:00.000 |       |      1 |     0.1 |      0.1 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      | [3, [4, 5]] |
+| 2022-01-01 00:00:00.000 |       |      1 |     0.1 |      0.1 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      | my_empty    |
+| 2022-01-01 00:00:00.000 |       |      1 |     0.1 |      0.1 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      | my_null     |
+| 2022-01-01 00:00:00.000 | str2  |      2 |     0.2 |      0.2 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      | 1           |
+| 2022-01-01 00:00:00.000 | str2  |      2 |     0.2 |      0.2 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      | [2]         |
+| 2022-01-01 00:00:00.000 | str2  |      2 |     0.2 |      0.2 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      | [3, [4, 5]] |
+| 2022-01-01 00:00:00.000 | str2  |      2 |     0.2 |      0.2 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      | my_empty    |
+| 2022-01-01 00:00:00.000 | str2  |      2 |     0.2 |      0.2 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      | my_null     |
+| 2022-01-01 00:00:00.000 | str3  |      3 |     0.3 |      0.3 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      | 1           |
+| 2022-01-01 00:00:00.000 | str3  |      3 |     0.3 |      0.3 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      | [2]         |
+| 2022-01-01 00:00:00.000 | str3  |      3 |     0.3 |      0.3 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      | [3, [4, 5]] |
+| 2022-01-01 00:00:00.000 | str3  |      3 |     0.3 |      0.3 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      | my_empty    |
+| 2022-01-01 00:00:00.000 | str3  |      3 |     0.3 |      0.3 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      | my_null     |
+| 2022-01-01 00:00:00.000 | str4  |      4 |     0.4 |      0.4 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      | 1           |
+| 2022-01-01 00:00:00.000 | str4  |      4 |     0.4 |      0.4 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      | [2]         |
+| 2022-01-01 00:00:00.000 | str4  |      4 |     0.4 |      0.4 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      | [3, [4, 5]] |
+| 2022-01-01 00:00:00.000 | str4  |      4 |     0.4 |      0.4 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      | my_empty    |
+| 2022-01-01 00:00:00.000 | str4  |      4 |     0.4 |      0.4 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      | my_null     |
+| 2022-01-01 00:00:00.000 |       |      0 |     0.0 |      0.0 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      | 1           |
+| 2022-01-01 00:00:00.000 |       |      0 |     0.0 |      0.0 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      | [2]         |
+| 2022-01-01 00:00:00.000 |       |      0 |     0.0 |      0.0 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      | [3, [4, 5]] |
+| 2022-01-01 00:00:00.000 |       |      0 |     0.0 |      0.0 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      | my_empty    |
+| 2022-01-01 00:00:00.000 |       |      0 |     0.0 |      0.0 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      | my_null     |
++-------------------------+-------+--------+---------+----------+------------------------------------------------+------------------------+--------------------------------------+----------------------------------+--------------------------------------+----------------------------------+-----------------------------+-------------+
+(25 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "unnest",
+    "base" : {
+      "type" : "table",
+      "name" : "test_unnest"
+    },
+    "virtualColumn" : {
+      "type" : "expression",
+      "name" : "j0.unnest",
+      "expression" : "\"c_mv_complex\"",
+      "outputType" : "STRING"
+    },
+    "unnestFilter" : null
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "resultFormat" : "compactedList",
+  "columns" : [ "__time", "c_str", "c_long", "c_float", "c_double", "c_mv_complex", "c_mv_num", "c_mv_complex_with_null_and_empty_val", "c_mv_num_with_null_and_empty_val", "c_mv_complex_with_null_and_empty_row", "c_mv_num_with_null_and_empty_row", "c_mv_all_null_and_empty_val", "j0.unnest" ],
+  "columnTypes" : [ "LONG", "STRING", "LONG", "FLOAT", "DOUBLE", "STRING", "STRING", "STRING", "STRING", "STRING", "STRING", "STRING", "STRING" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A1_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY c;
++-------------+-----+
+| c           | cnt |
++-------------+-----+
+| 1           |   5 |
+| [2]         |   5 |
+| [3, [4, 5]] |   5 |
+| my_empty    |   5 |
+| my_null     |   5 |
++-------------+-----+
+(5 rows)
+
+!ok
+
+{
+  "queryType" : "groupBy",
+  "dataSource" : {
+    "type" : "unnest",
+    "base" : {
+      "type" : "table",
+      "name" : "test_unnest"
+    },
+    "virtualColumn" : {
+      "type" : "expression",
+      "name" : "j0.unnest",
+      "expression" : "\"c_mv_complex\"",
+      "outputType" : "STRING"
+    },
+    "unnestFilter" : null
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "granularity" : {
+    "type" : "all"
+  },
+  "dimensions" : [ {
+    "type" : "default",
+    "dimension" : "j0.unnest",
+    "outputName" : "d0",
+    "outputType" : "STRING"
+  } ],
+  "aggregations" : [ {
+    "type" : "count",
+    "name" : "a0"
+  } ],
+  "limitSpec" : {
+    "type" : "NoopLimitSpec"
+  }
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c);
++-----+
+| cnt |
++-----+
+|  25 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A1_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c);
++-----+
+| cnt |
++-----+
+|  25 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A1_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A2_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c);
++-----+
+| cnt |
++-----+
+|  25 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A2_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c);
++-----+
+| cnt |
++-----+
+|  25 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A2_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A3_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-----+
+| cnt |
++-----+
+|  25 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A3_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-----+
+| cnt |
++-----+
+|  20 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A3_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++-----+
+| cnt |
++-----+
+|  25 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A4_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++-----+
+| cnt |
++-----+
+|  20 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A4_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++-----+
+| cnt |
++-----+
+|  25 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A5_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++-----+
+| cnt |
++-----+
+|  10 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A5_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A1_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY c;
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A2_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c);
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A2_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY c;
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A3_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A3_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY c;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A4_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A5_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY c;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A6_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A7_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY c;
++---+
+| c |
++---+
+|   |
+|   |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c1,
+       c2
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u1(c1),
+     unnest(mv_to_array(c_mv_complex)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN ('my_null',
+                 'my_empty',
+                 '1',
+                 '[2]',
+                 '[3, [4, 5]]'))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+-------------+-------------+
+| c_long | c1          | c2          |
++--------+-------------+-------------+
+|      0 | 1           | 1           |
+|      0 | 1           | [2]         |
+|      0 | 1           | [3, [4, 5]] |
+|      0 | 1           | my_empty    |
+|      0 | 1           | my_null     |
+|      0 | [2]         | 1           |
+|      0 | [2]         | [2]         |
+|      0 | [2]         | [3, [4, 5]] |
+|      0 | [2]         | my_empty    |
+|      0 | [2]         | my_null     |
+|      0 | [3, [4, 5]] | 1           |
+|      0 | [3, [4, 5]] | [2]         |
+|      0 | [3, [4, 5]] | [3, [4, 5]] |
+|      0 | [3, [4, 5]] | my_empty    |
+|      0 | [3, [4, 5]] | my_null     |
+|      0 | my_empty    | 1           |
+|      0 | my_empty    | [2]         |
+|      0 | my_empty    | [3, [4, 5]] |
+|      0 | my_empty    | my_empty    |
+|      0 | my_empty    | my_null     |
+|      0 | my_null     | 1           |
+|      0 | my_null     | [2]         |
+|      0 | my_null     | [3, [4, 5]] |
+|      0 | my_null     | my_empty    |
+|      0 | my_null     | my_null     |
+|      1 | 1           | 1           |
+|      1 | 1           | [2]         |
+|      1 | 1           | [3, [4, 5]] |
+|      1 | 1           | my_empty    |
+|      1 | 1           | my_null     |
+|      1 | [2]         | 1           |
+|      1 | [2]         | [2]         |
+|      1 | [2]         | [3, [4, 5]] |
+|      1 | [2]         | my_empty    |
+|      1 | [2]         | my_null     |
+|      1 | [3, [4, 5]] | 1           |
+|      1 | [3, [4, 5]] | [2]         |
+|      1 | [3, [4, 5]] | [3, [4, 5]] |
+|      1 | [3, [4, 5]] | my_empty    |
+|      1 | [3, [4, 5]] | my_null     |
+|      1 | my_empty    | 1           |
+|      1 | my_empty    | [2]         |
+|      1 | my_empty    | [3, [4, 5]] |
+|      1 | my_empty    | my_empty    |
+|      1 | my_empty    | my_null     |
+|      1 | my_null     | 1           |
+|      1 | my_null     | [2]         |
+|      1 | my_null     | [3, [4, 5]] |
+|      1 | my_null     | my_empty    |
+|      1 | my_null     | my_null     |
+|      2 | 1           | 1           |
+|      2 | 1           | [2]         |
+|      2 | 1           | [3, [4, 5]] |
+|      2 | 1           | my_empty    |
+|      2 | 1           | my_null     |
+|      2 | [2]         | 1           |
+|      2 | [2]         | [2]         |
+|      2 | [2]         | [3, [4, 5]] |
+|      2 | [2]         | my_empty    |
+|      2 | [2]         | my_null     |
+|      2 | [3, [4, 5]] | 1           |
+|      2 | [3, [4, 5]] | [2]         |
+|      2 | [3, [4, 5]] | [3, [4, 5]] |
+|      2 | [3, [4, 5]] | my_empty    |
+|      2 | [3, [4, 5]] | my_null     |
+|      2 | my_empty    | 1           |
+|      2 | my_empty    | [2]         |
+|      2 | my_empty    | [3, [4, 5]] |
+|      2 | my_empty    | my_empty    |
+|      2 | my_empty    | my_null     |
+|      2 | my_null     | 1           |
+|      2 | my_null     | [2]         |
+|      2 | my_null     | [3, [4, 5]] |
+|      2 | my_null     | my_empty    |
+|      2 | my_null     | my_null     |
+|      3 | 1           | 1           |
+|      3 | 1           | [2]         |
+|      3 | 1           | [3, [4, 5]] |
+|      3 | 1           | my_empty    |
+|      3 | 1           | my_null     |
+|      3 | [2]         | 1           |
+|      3 | [2]         | [2]         |
+|      3 | [2]         | [3, [4, 5]] |
+|      3 | [2]         | my_empty    |
+|      3 | [2]         | my_null     |
+|      3 | [3, [4, 5]] | 1           |
+|      3 | [3, [4, 5]] | [2]         |
+|      3 | [3, [4, 5]] | [3, [4, 5]] |
+|      3 | [3, [4, 5]] | my_empty    |
+|      3 | [3, [4, 5]] | my_null     |
+|      3 | my_empty    | 1           |
+|      3 | my_empty    | [2]         |
+|      3 | my_empty    | [3, [4, 5]] |
+|      3 | my_empty    | my_empty    |
+|      3 | my_empty    | my_null     |
+|      3 | my_null     | 1           |
+|      3 | my_null     | [2]         |
+|      3 | my_null     | [3, [4, 5]] |
+|      3 | my_null     | my_empty    |
+|      3 | my_null     | my_null     |
+|      4 | 1           | 1           |
+|      4 | 1           | [2]         |
+|      4 | 1           | [3, [4, 5]] |
+|      4 | 1           | my_empty    |
+|      4 | 1           | my_null     |
+|      4 | [2]         | 1           |
+|      4 | [2]         | [2]         |
+|      4 | [2]         | [3, [4, 5]] |
+|      4 | [2]         | my_empty    |
+|      4 | [2]         | my_null     |
+|      4 | [3, [4, 5]] | 1           |
+|      4 | [3, [4, 5]] | [2]         |
+|      4 | [3, [4, 5]] | [3, [4, 5]] |
+|      4 | [3, [4, 5]] | my_empty    |
+|      4 | [3, [4, 5]] | my_null     |
+|      4 | my_empty    | 1           |
+|      4 | my_empty    | [2]         |
+|      4 | my_empty    | [3, [4, 5]] |
+|      4 | my_empty    | my_empty    |
+|      4 | my_empty    | my_null     |
+|      4 | my_null     | 1           |
+|      4 | my_null     | [2]         |
+|      4 | my_null     | [3, [4, 5]] |
+|      4 | my_null     | my_empty    |
+|      4 | my_null     | my_null     |
++--------+-------------+-------------+
+(125 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A1_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c1,
+       c2
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u1(c1)), unnest(mv_to_array(c_mv_complex)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN ('my_null',
+                 'my_empty',
+                 '1',
+                 '[2]',
+                 '[3, [4, 5]]'))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+-------------+-------------+
+| c_long | c1          | c2          |
++--------+-------------+-------------+
+|      0 | 1           | 1           |
+|      0 | 1           | [2]         |
+|      0 | 1           | [3, [4, 5]] |
+|      0 | 1           | my_empty    |
+|      0 | 1           | my_null     |
+|      0 | [2]         | 1           |
+|      0 | [2]         | [2]         |
+|      0 | [2]         | [3, [4, 5]] |
+|      0 | [2]         | my_empty    |
+|      0 | [2]         | my_null     |
+|      0 | [3, [4, 5]] | 1           |
+|      0 | [3, [4, 5]] | [2]         |
+|      0 | [3, [4, 5]] | [3, [4, 5]] |
+|      0 | [3, [4, 5]] | my_empty    |
+|      0 | [3, [4, 5]] | my_null     |
+|      0 | my_empty    | 1           |
+|      0 | my_empty    | [2]         |
+|      0 | my_empty    | [3, [4, 5]] |
+|      0 | my_empty    | my_empty    |
+|      0 | my_empty    | my_null     |
+|      0 | my_null     | 1           |
+|      0 | my_null     | [2]         |
+|      0 | my_null     | [3, [4, 5]] |
+|      0 | my_null     | my_empty    |
+|      0 | my_null     | my_null     |
+|      1 | 1           | 1           |
+|      1 | 1           | [2]         |
+|      1 | 1           | [3, [4, 5]] |
+|      1 | 1           | my_empty    |
+|      1 | 1           | my_null     |
+|      1 | [2]         | 1           |
+|      1 | [2]         | [2]         |
+|      1 | [2]         | [3, [4, 5]] |
+|      1 | [2]         | my_empty    |
+|      1 | [2]         | my_null     |
+|      1 | [3, [4, 5]] | 1           |
+|      1 | [3, [4, 5]] | [2]         |
+|      1 | [3, [4, 5]] | [3, [4, 5]] |
+|      1 | [3, [4, 5]] | my_empty    |
+|      1 | [3, [4, 5]] | my_null     |
+|      1 | my_empty    | 1           |
+|      1 | my_empty    | [2]         |
+|      1 | my_empty    | [3, [4, 5]] |
+|      1 | my_empty    | my_empty    |
+|      1 | my_empty    | my_null     |
+|      1 | my_null     | 1           |
+|      1 | my_null     | [2]         |
+|      1 | my_null     | [3, [4, 5]] |
+|      1 | my_null     | my_empty    |
+|      1 | my_null     | my_null     |
+|      2 | 1           | 1           |
+|      2 | 1           | [2]         |
+|      2 | 1           | [3, [4, 5]] |
+|      2 | 1           | my_empty    |
+|      2 | 1           | my_null     |
+|      2 | [2]         | 1           |
+|      2 | [2]         | [2]         |
+|      2 | [2]         | [3, [4, 5]] |
+|      2 | [2]         | my_empty    |
+|      2 | [2]         | my_null     |
+|      2 | [3, [4, 5]] | 1           |
+|      2 | [3, [4, 5]] | [2]         |
+|      2 | [3, [4, 5]] | [3, [4, 5]] |
+|      2 | [3, [4, 5]] | my_empty    |
+|      2 | [3, [4, 5]] | my_null     |
+|      2 | my_empty    | 1           |
+|      2 | my_empty    | [2]         |
+|      2 | my_empty    | [3, [4, 5]] |
+|      2 | my_empty    | my_empty    |
+|      2 | my_empty    | my_null     |
+|      2 | my_null     | 1           |
+|      2 | my_null     | [2]         |
+|      2 | my_null     | [3, [4, 5]] |
+|      2 | my_null     | my_empty    |
+|      2 | my_null     | my_null     |
+|      3 | 1           | 1           |
+|      3 | 1           | [2]         |
+|      3 | 1           | [3, [4, 5]] |
+|      3 | 1           | my_empty    |
+|      3 | 1           | my_null     |
+|      3 | [2]         | 1           |
+|      3 | [2]         | [2]         |
+|      3 | [2]         | [3, [4, 5]] |
+|      3 | [2]         | my_empty    |
+|      3 | [2]         | my_null     |
+|      3 | [3, [4, 5]] | 1           |
+|      3 | [3, [4, 5]] | [2]         |
+|      3 | [3, [4, 5]] | [3, [4, 5]] |
+|      3 | [3, [4, 5]] | my_empty    |
+|      3 | [3, [4, 5]] | my_null     |
+|      3 | my_empty    | 1           |
+|      3 | my_empty    | [2]         |
+|      3 | my_empty    | [3, [4, 5]] |
+|      3 | my_empty    | my_empty    |
+|      3 | my_empty    | my_null     |
+|      3 | my_null     | 1           |
+|      3 | my_null     | [2]         |
+|      3 | my_null     | [3, [4, 5]] |
+|      3 | my_null     | my_empty    |
+|      3 | my_null     | my_null     |
+|      4 | 1           | 1           |
+|      4 | 1           | [2]         |
+|      4 | 1           | [3, [4, 5]] |
+|      4 | 1           | my_empty    |
+|      4 | 1           | my_null     |
+|      4 | [2]         | 1           |
+|      4 | [2]         | [2]         |
+|      4 | [2]         | [3, [4, 5]] |
+|      4 | [2]         | my_empty    |
+|      4 | [2]         | my_null     |
+|      4 | [3, [4, 5]] | 1           |
+|      4 | [3, [4, 5]] | [2]         |
+|      4 | [3, [4, 5]] | [3, [4, 5]] |
+|      4 | [3, [4, 5]] | my_empty    |
+|      4 | [3, [4, 5]] | my_null     |
+|      4 | my_empty    | 1           |
+|      4 | my_empty    | [2]         |
+|      4 | my_empty    | [3, [4, 5]] |
+|      4 | my_empty    | my_empty    |
+|      4 | my_empty    | my_null     |
+|      4 | my_null     | 1           |
+|      4 | my_null     | [2]         |
+|      4 | my_null     | [3, [4, 5]] |
+|      4 | my_null     | my_empty    |
+|      4 | my_null     | my_null     |
++--------+-------------+-------------+
+(125 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A1_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u1(c1))
+SELECT c_long,
+       c1,
+       c2
+FROM t1,
+     unnest(mv_to_array(c_mv_complex)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN ('my_null',
+                 'my_empty',
+                 '1',
+                 '[2]',
+                 '[3, [4, 5]]'))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+-------------+-------------+
+| c_long | c1          | c2          |
++--------+-------------+-------------+
+|      0 | 1           | 1           |
+|      0 | 1           | [2]         |
+|      0 | 1           | [3, [4, 5]] |
+|      0 | 1           | my_empty    |
+|      0 | 1           | my_null     |
+|      0 | [2]         | 1           |
+|      0 | [2]         | [2]         |
+|      0 | [2]         | [3, [4, 5]] |
+|      0 | [2]         | my_empty    |
+|      0 | [2]         | my_null     |
+|      0 | [3, [4, 5]] | 1           |
+|      0 | [3, [4, 5]] | [2]         |
+|      0 | [3, [4, 5]] | [3, [4, 5]] |
+|      0 | [3, [4, 5]] | my_empty    |
+|      0 | [3, [4, 5]] | my_null     |
+|      0 | my_empty    | 1           |
+|      0 | my_empty    | [2]         |
+|      0 | my_empty    | [3, [4, 5]] |
+|      0 | my_empty    | my_empty    |
+|      0 | my_empty    | my_null     |
+|      0 | my_null     | 1           |
+|      0 | my_null     | [2]         |
+|      0 | my_null     | [3, [4, 5]] |
+|      0 | my_null     | my_empty    |
+|      0 | my_null     | my_null     |
+|      1 | 1           | 1           |
+|      1 | 1           | [2]         |
+|      1 | 1           | [3, [4, 5]] |
+|      1 | 1           | my_empty    |
+|      1 | 1           | my_null     |
+|      1 | [2]         | 1           |
+|      1 | [2]         | [2]         |
+|      1 | [2]         | [3, [4, 5]] |
+|      1 | [2]         | my_empty    |
+|      1 | [2]         | my_null     |
+|      1 | [3, [4, 5]] | 1           |
+|      1 | [3, [4, 5]] | [2]         |
+|      1 | [3, [4, 5]] | [3, [4, 5]] |
+|      1 | [3, [4, 5]] | my_empty    |
+|      1 | [3, [4, 5]] | my_null     |
+|      1 | my_empty    | 1           |
+|      1 | my_empty    | [2]         |
+|      1 | my_empty    | [3, [4, 5]] |
+|      1 | my_empty    | my_empty    |
+|      1 | my_empty    | my_null     |
+|      1 | my_null     | 1           |
+|      1 | my_null     | [2]         |
+|      1 | my_null     | [3, [4, 5]] |
+|      1 | my_null     | my_empty    |
+|      1 | my_null     | my_null     |
+|      2 | 1           | 1           |
+|      2 | 1           | [2]         |
+|      2 | 1           | [3, [4, 5]] |
+|      2 | 1           | my_empty    |
+|      2 | 1           | my_null     |
+|      2 | [2]         | 1           |
+|      2 | [2]         | [2]         |
+|      2 | [2]         | [3, [4, 5]] |
+|      2 | [2]         | my_empty    |
+|      2 | [2]         | my_null     |
+|      2 | [3, [4, 5]] | 1           |
+|      2 | [3, [4, 5]] | [2]         |
+|      2 | [3, [4, 5]] | [3, [4, 5]] |
+|      2 | [3, [4, 5]] | my_empty    |
+|      2 | [3, [4, 5]] | my_null     |
+|      2 | my_empty    | 1           |
+|      2 | my_empty    | [2]         |
+|      2 | my_empty    | [3, [4, 5]] |
+|      2 | my_empty    | my_empty    |
+|      2 | my_empty    | my_null     |
+|      2 | my_null     | 1           |
+|      2 | my_null     | [2]         |
+|      2 | my_null     | [3, [4, 5]] |
+|      2 | my_null     | my_empty    |
+|      2 | my_null     | my_null     |
+|      3 | 1           | 1           |
+|      3 | 1           | [2]         |
+|      3 | 1           | [3, [4, 5]] |
+|      3 | 1           | my_empty    |
+|      3 | 1           | my_null     |
+|      3 | [2]         | 1           |
+|      3 | [2]         | [2]         |
+|      3 | [2]         | [3, [4, 5]] |
+|      3 | [2]         | my_empty    |
+|      3 | [2]         | my_null     |
+|      3 | [3, [4, 5]] | 1           |
+|      3 | [3, [4, 5]] | [2]         |
+|      3 | [3, [4, 5]] | [3, [4, 5]] |
+|      3 | [3, [4, 5]] | my_empty    |
+|      3 | [3, [4, 5]] | my_null     |
+|      3 | my_empty    | 1           |
+|      3 | my_empty    | [2]         |
+|      3 | my_empty    | [3, [4, 5]] |
+|      3 | my_empty    | my_empty    |
+|      3 | my_empty    | my_null     |
+|      3 | my_null     | 1           |
+|      3 | my_null     | [2]         |
+|      3 | my_null     | [3, [4, 5]] |
+|      3 | my_null     | my_empty    |
+|      3 | my_null     | my_null     |
+|      4 | 1           | 1           |
+|      4 | 1           | [2]         |
+|      4 | 1           | [3, [4, 5]] |
+|      4 | 1           | my_empty    |
+|      4 | 1           | my_null     |
+|      4 | [2]         | 1           |
+|      4 | [2]         | [2]         |
+|      4 | [2]         | [3, [4, 5]] |
+|      4 | [2]         | my_empty    |
+|      4 | [2]         | my_null     |
+|      4 | [3, [4, 5]] | 1           |
+|      4 | [3, [4, 5]] | [2]         |
+|      4 | [3, [4, 5]] | [3, [4, 5]] |
+|      4 | [3, [4, 5]] | my_empty    |
+|      4 | [3, [4, 5]] | my_null     |
+|      4 | my_empty    | 1           |
+|      4 | my_empty    | [2]         |
+|      4 | my_empty    | [3, [4, 5]] |
+|      4 | my_empty    | my_empty    |
+|      4 | my_empty    | my_null     |
+|      4 | my_null     | 1           |
+|      4 | my_null     | [2]         |
+|      4 | my_null     | [3, [4, 5]] |
+|      4 | my_null     | my_empty    |
+|      4 | my_null     | my_null     |
++--------+-------------+-------------+
+(125 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A2_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c1,
+       c2
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u1(c1),
+     unnest(mv_to_array(c_mv_num)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN ('-1',
+                 '0',
+                 '1',
+                 '2',
+                 '3'))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+----+----+
+| c_long | c1 | c2 |
++--------+----+----+
+|      0 | -1 | -1 |
+|      0 | -1 | 0  |
+|      0 | -1 | 1  |
+|      0 | -1 | 2  |
+|      0 | -1 | 3  |
+|      0 | 0  | -1 |
+|      0 | 0  | 0  |
+|      0 | 0  | 1  |
+|      0 | 0  | 2  |
+|      0 | 0  | 3  |
+|      0 | 1  | -1 |
+|      0 | 1  | 0  |
+|      0 | 1  | 1  |
+|      0 | 1  | 2  |
+|      0 | 1  | 3  |
+|      0 | 2  | -1 |
+|      0 | 2  | 0  |
+|      0 | 2  | 1  |
+|      0 | 2  | 2  |
+|      0 | 2  | 3  |
+|      0 | 3  | -1 |
+|      0 | 3  | 0  |
+|      0 | 3  | 1  |
+|      0 | 3  | 2  |
+|      0 | 3  | 3  |
+|      1 | -1 | -1 |
+|      1 | -1 | 0  |
+|      1 | -1 | 1  |
+|      1 | -1 | 2  |
+|      1 | -1 | 3  |
+|      1 | 0  | -1 |
+|      1 | 0  | 0  |
+|      1 | 0  | 1  |
+|      1 | 0  | 2  |
+|      1 | 0  | 3  |
+|      1 | 1  | -1 |
+|      1 | 1  | 0  |
+|      1 | 1  | 1  |
+|      1 | 1  | 2  |
+|      1 | 1  | 3  |
+|      1 | 2  | -1 |
+|      1 | 2  | 0  |
+|      1 | 2  | 1  |
+|      1 | 2  | 2  |
+|      1 | 2  | 3  |
+|      1 | 3  | -1 |
+|      1 | 3  | 0  |
+|      1 | 3  | 1  |
+|      1 | 3  | 2  |
+|      1 | 3  | 3  |
+|      2 | -1 | -1 |
+|      2 | -1 | 0  |
+|      2 | -1 | 1  |
+|      2 | -1 | 2  |
+|      2 | -1 | 3  |
+|      2 | 0  | -1 |
+|      2 | 0  | 0  |
+|      2 | 0  | 1  |
+|      2 | 0  | 2  |
+|      2 | 0  | 3  |
+|      2 | 1  | -1 |
+|      2 | 1  | 0  |
+|      2 | 1  | 1  |
+|      2 | 1  | 2  |
+|      2 | 1  | 3  |
+|      2 | 2  | -1 |
+|      2 | 2  | 0  |
+|      2 | 2  | 1  |
+|      2 | 2  | 2  |
+|      2 | 2  | 3  |
+|      2 | 3  | -1 |
+|      2 | 3  | 0  |
+|      2 | 3  | 1  |
+|      2 | 3  | 2  |
+|      2 | 3  | 3  |
+|      3 | -1 | -1 |
+|      3 | -1 | 0  |
+|      3 | -1 | 1  |
+|      3 | -1 | 2  |
+|      3 | -1 | 3  |
+|      3 | 0  | -1 |
+|      3 | 0  | 0  |
+|      3 | 0  | 1  |
+|      3 | 0  | 2  |
+|      3 | 0  | 3  |
+|      3 | 1  | -1 |
+|      3 | 1  | 0  |
+|      3 | 1  | 1  |
+|      3 | 1  | 2  |
+|      3 | 1  | 3  |
+|      3 | 2  | -1 |
+|      3 | 2  | 0  |
+|      3 | 2  | 1  |
+|      3 | 2  | 2  |
+|      3 | 2  | 3  |
+|      3 | 3  | -1 |
+|      3 | 3  | 0  |
+|      3 | 3  | 1  |
+|      3 | 3  | 2  |
+|      3 | 3  | 3  |
+|      4 | -1 | -1 |
+|      4 | -1 | 0  |
+|      4 | -1 | 1  |
+|      4 | -1 | 2  |
+|      4 | -1 | 3  |
+|      4 | 0  | -1 |
+|      4 | 0  | 0  |
+|      4 | 0  | 1  |
+|      4 | 0  | 2  |
+|      4 | 0  | 3  |
+|      4 | 1  | -1 |
+|      4 | 1  | 0  |
+|      4 | 1  | 1  |
+|      4 | 1  | 2  |
+|      4 | 1  | 3  |
+|      4 | 2  | -1 |
+|      4 | 2  | 0  |
+|      4 | 2  | 1  |
+|      4 | 2  | 2  |
+|      4 | 2  | 3  |
+|      4 | 3  | -1 |
+|      4 | 3  | 0  |
+|      4 | 3  | 1  |
+|      4 | 3  | 2  |
+|      4 | 3  | 3  |
++--------+----+----+
+(125 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A2_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c1,
+       c2
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u1(c1)), unnest(mv_to_array(c_mv_num)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN ('-1',
+                 '0',
+                 '1',
+                 '2',
+                 '3'))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+----+----+
+| c_long | c1 | c2 |
++--------+----+----+
+|      0 | -1 | -1 |
+|      0 | -1 | 0  |
+|      0 | -1 | 1  |
+|      0 | -1 | 2  |
+|      0 | -1 | 3  |
+|      0 | 0  | -1 |
+|      0 | 0  | 0  |
+|      0 | 0  | 1  |
+|      0 | 0  | 2  |
+|      0 | 0  | 3  |
+|      0 | 1  | -1 |
+|      0 | 1  | 0  |
+|      0 | 1  | 1  |
+|      0 | 1  | 2  |
+|      0 | 1  | 3  |
+|      0 | 2  | -1 |
+|      0 | 2  | 0  |
+|      0 | 2  | 1  |
+|      0 | 2  | 2  |
+|      0 | 2  | 3  |
+|      0 | 3  | -1 |
+|      0 | 3  | 0  |
+|      0 | 3  | 1  |
+|      0 | 3  | 2  |
+|      0 | 3  | 3  |
+|      1 | -1 | -1 |
+|      1 | -1 | 0  |
+|      1 | -1 | 1  |
+|      1 | -1 | 2  |
+|      1 | -1 | 3  |
+|      1 | 0  | -1 |
+|      1 | 0  | 0  |
+|      1 | 0  | 1  |
+|      1 | 0  | 2  |
+|      1 | 0  | 3  |
+|      1 | 1  | -1 |
+|      1 | 1  | 0  |
+|      1 | 1  | 1  |
+|      1 | 1  | 2  |
+|      1 | 1  | 3  |
+|      1 | 2  | -1 |
+|      1 | 2  | 0  |
+|      1 | 2  | 1  |
+|      1 | 2  | 2  |
+|      1 | 2  | 3  |
+|      1 | 3  | -1 |
+|      1 | 3  | 0  |
+|      1 | 3  | 1  |
+|      1 | 3  | 2  |
+|      1 | 3  | 3  |
+|      2 | -1 | -1 |
+|      2 | -1 | 0  |
+|      2 | -1 | 1  |
+|      2 | -1 | 2  |
+|      2 | -1 | 3  |
+|      2 | 0  | -1 |
+|      2 | 0  | 0  |
+|      2 | 0  | 1  |
+|      2 | 0  | 2  |
+|      2 | 0  | 3  |
+|      2 | 1  | -1 |
+|      2 | 1  | 0  |
+|      2 | 1  | 1  |
+|      2 | 1  | 2  |
+|      2 | 1  | 3  |
+|      2 | 2  | -1 |
+|      2 | 2  | 0  |
+|      2 | 2  | 1  |
+|      2 | 2  | 2  |
+|      2 | 2  | 3  |
+|      2 | 3  | -1 |
+|      2 | 3  | 0  |
+|      2 | 3  | 1  |
+|      2 | 3  | 2  |
+|      2 | 3  | 3  |
+|      3 | -1 | -1 |
+|      3 | -1 | 0  |
+|      3 | -1 | 1  |
+|      3 | -1 | 2  |
+|      3 | -1 | 3  |
+|      3 | 0  | -1 |
+|      3 | 0  | 0  |
+|      3 | 0  | 1  |
+|      3 | 0  | 2  |
+|      3 | 0  | 3  |
+|      3 | 1  | -1 |
+|      3 | 1  | 0  |
+|      3 | 1  | 1  |
+|      3 | 1  | 2  |
+|      3 | 1  | 3  |
+|      3 | 2  | -1 |
+|      3 | 2  | 0  |
+|      3 | 2  | 1  |
+|      3 | 2  | 2  |
+|      3 | 2  | 3  |
+|      3 | 3  | -1 |
+|      3 | 3  | 0  |
+|      3 | 3  | 1  |
+|      3 | 3  | 2  |
+|      3 | 3  | 3  |
+|      4 | -1 | -1 |
+|      4 | -1 | 0  |
+|      4 | -1 | 1  |
+|      4 | -1 | 2  |
+|      4 | -1 | 3  |
+|      4 | 0  | -1 |
+|      4 | 0  | 0  |
+|      4 | 0  | 1  |
+|      4 | 0  | 2  |
+|      4 | 0  | 3  |
+|      4 | 1  | -1 |
+|      4 | 1  | 0  |
+|      4 | 1  | 1  |
+|      4 | 1  | 2  |
+|      4 | 1  | 3  |
+|      4 | 2  | -1 |
+|      4 | 2  | 0  |
+|      4 | 2  | 1  |
+|      4 | 2  | 2  |
+|      4 | 2  | 3  |
+|      4 | 3  | -1 |
+|      4 | 3  | 0  |
+|      4 | 3  | 1  |
+|      4 | 3  | 2  |
+|      4 | 3  | 3  |
++--------+----+----+
+(125 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A2_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u1(c1))
+SELECT c_long,
+       c1,
+       c2
+FROM t1,
+     unnest(mv_to_array(c_mv_num)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN ('-1',
+                 '0',
+                 '1',
+                 '2',
+                 '3'))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+----+----+
+| c_long | c1 | c2 |
++--------+----+----+
+|      0 | -1 | -1 |
+|      0 | -1 | 0  |
+|      0 | -1 | 1  |
+|      0 | -1 | 2  |
+|      0 | -1 | 3  |
+|      0 | 0  | -1 |
+|      0 | 0  | 0  |
+|      0 | 0  | 1  |
+|      0 | 0  | 2  |
+|      0 | 0  | 3  |
+|      0 | 1  | -1 |
+|      0 | 1  | 0  |
+|      0 | 1  | 1  |
+|      0 | 1  | 2  |
+|      0 | 1  | 3  |
+|      0 | 2  | -1 |
+|      0 | 2  | 0  |
+|      0 | 2  | 1  |
+|      0 | 2  | 2  |
+|      0 | 2  | 3  |
+|      0 | 3  | -1 |
+|      0 | 3  | 0  |
+|      0 | 3  | 1  |
+|      0 | 3  | 2  |
+|      0 | 3  | 3  |
+|      1 | -1 | -1 |
+|      1 | -1 | 0  |
+|      1 | -1 | 1  |
+|      1 | -1 | 2  |
+|      1 | -1 | 3  |
+|      1 | 0  | -1 |
+|      1 | 0  | 0  |
+|      1 | 0  | 1  |
+|      1 | 0  | 2  |
+|      1 | 0  | 3  |
+|      1 | 1  | -1 |
+|      1 | 1  | 0  |
+|      1 | 1  | 1  |
+|      1 | 1  | 2  |
+|      1 | 1  | 3  |
+|      1 | 2  | -1 |
+|      1 | 2  | 0  |
+|      1 | 2  | 1  |
+|      1 | 2  | 2  |
+|      1 | 2  | 3  |
+|      1 | 3  | -1 |
+|      1 | 3  | 0  |
+|      1 | 3  | 1  |
+|      1 | 3  | 2  |
+|      1 | 3  | 3  |
+|      2 | -1 | -1 |
+|      2 | -1 | 0  |
+|      2 | -1 | 1  |
+|      2 | -1 | 2  |
+|      2 | -1 | 3  |
+|      2 | 0  | -1 |
+|      2 | 0  | 0  |
+|      2 | 0  | 1  |
+|      2 | 0  | 2  |
+|      2 | 0  | 3  |
+|      2 | 1  | -1 |
+|      2 | 1  | 0  |
+|      2 | 1  | 1  |
+|      2 | 1  | 2  |
+|      2 | 1  | 3  |
+|      2 | 2  | -1 |
+|      2 | 2  | 0  |
+|      2 | 2  | 1  |
+|      2 | 2  | 2  |
+|      2 | 2  | 3  |
+|      2 | 3  | -1 |
+|      2 | 3  | 0  |
+|      2 | 3  | 1  |
+|      2 | 3  | 2  |
+|      2 | 3  | 3  |
+|      3 | -1 | -1 |
+|      3 | -1 | 0  |
+|      3 | -1 | 1  |
+|      3 | -1 | 2  |
+|      3 | -1 | 3  |
+|      3 | 0  | -1 |
+|      3 | 0  | 0  |
+|      3 | 0  | 1  |
+|      3 | 0  | 2  |
+|      3 | 0  | 3  |
+|      3 | 1  | -1 |
+|      3 | 1  | 0  |
+|      3 | 1  | 1  |
+|      3 | 1  | 2  |
+|      3 | 1  | 3  |
+|      3 | 2  | -1 |
+|      3 | 2  | 0  |
+|      3 | 2  | 1  |
+|      3 | 2  | 2  |
+|      3 | 2  | 3  |
+|      3 | 3  | -1 |
+|      3 | 3  | 0  |
+|      3 | 3  | 1  |
+|      3 | 3  | 2  |
+|      3 | 3  | 3  |
+|      4 | -1 | -1 |
+|      4 | -1 | 0  |
+|      4 | -1 | 1  |
+|      4 | -1 | 2  |
+|      4 | -1 | 3  |
+|      4 | 0  | -1 |
+|      4 | 0  | 0  |
+|      4 | 0  | 1  |
+|      4 | 0  | 2  |
+|      4 | 0  | 3  |
+|      4 | 1  | -1 |
+|      4 | 1  | 0  |
+|      4 | 1  | 1  |
+|      4 | 1  | 2  |
+|      4 | 1  | 3  |
+|      4 | 2  | -1 |
+|      4 | 2  | 0  |
+|      4 | 2  | 1  |
+|      4 | 2  | 2  |
+|      4 | 2  | 3  |
+|      4 | 3  | -1 |
+|      4 | 3  | 0  |
+|      4 | 3  | 1  |
+|      4 | 3  | 2  |
+|      4 | 3  | 3  |
++--------+----+----+
+(125 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A3_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c1,
+       c2
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u1(c1),
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN ('',
+                 '1',
+                 '[2]',
+                 '[3, [4, 5]]'))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+-------------+-------------+
+| c_long | c1          | c2          |
++--------+-------------+-------------+
+|      0 |             |             |
+|      0 |             | 1           |
+|      0 |             | [2]         |
+|      0 |             | [3, [4, 5]] |
+|      0 |             |             |
+|      0 | 1           |             |
+|      0 | 1           | 1           |
+|      0 | 1           | [2]         |
+|      0 | 1           | [3, [4, 5]] |
+|      0 | 1           |             |
+|      0 | [2]         |             |
+|      0 | [2]         | 1           |
+|      0 | [2]         | [2]         |
+|      0 | [2]         | [3, [4, 5]] |
+|      0 | [2]         |             |
+|      0 | [3, [4, 5]] |             |
+|      0 | [3, [4, 5]] | 1           |
+|      0 | [3, [4, 5]] | [2]         |
+|      0 | [3, [4, 5]] | [3, [4, 5]] |
+|      0 | [3, [4, 5]] |             |
+|      0 |             |             |
+|      0 |             | 1           |
+|      0 |             | [2]         |
+|      0 |             | [3, [4, 5]] |
+|      0 |             |             |
+|      1 |             |             |
+|      1 |             | 1           |
+|      1 |             | [2]         |
+|      1 |             | [3, [4, 5]] |
+|      1 |             |             |
+|      1 | 1           |             |
+|      1 | 1           | 1           |
+|      1 | 1           | [2]         |
+|      1 | 1           | [3, [4, 5]] |
+|      1 | 1           |             |
+|      1 | [2]         |             |
+|      1 | [2]         | 1           |
+|      1 | [2]         | [2]         |
+|      1 | [2]         | [3, [4, 5]] |
+|      1 | [2]         |             |
+|      1 | [3, [4, 5]] |             |
+|      1 | [3, [4, 5]] | 1           |
+|      1 | [3, [4, 5]] | [2]         |
+|      1 | [3, [4, 5]] | [3, [4, 5]] |
+|      1 | [3, [4, 5]] |             |
+|      1 |             |             |
+|      1 |             | 1           |
+|      1 |             | [2]         |
+|      1 |             | [3, [4, 5]] |
+|      1 |             |             |
+|      2 |             |             |
+|      2 |             | 1           |
+|      2 |             | [2]         |
+|      2 |             | [3, [4, 5]] |
+|      2 |             |             |
+|      2 | 1           |             |
+|      2 | 1           | 1           |
+|      2 | 1           | [2]         |
+|      2 | 1           | [3, [4, 5]] |
+|      2 | 1           |             |
+|      2 | [2]         |             |
+|      2 | [2]         | 1           |
+|      2 | [2]         | [2]         |
+|      2 | [2]         | [3, [4, 5]] |
+|      2 | [2]         |             |
+|      2 | [3, [4, 5]] |             |
+|      2 | [3, [4, 5]] | 1           |
+|      2 | [3, [4, 5]] | [2]         |
+|      2 | [3, [4, 5]] | [3, [4, 5]] |
+|      2 | [3, [4, 5]] |             |
+|      2 |             |             |
+|      2 |             | 1           |
+|      2 |             | [2]         |
+|      2 |             | [3, [4, 5]] |
+|      2 |             |             |
+|      3 |             |             |
+|      3 |             | 1           |
+|      3 |             | [2]         |
+|      3 |             | [3, [4, 5]] |
+|      3 |             |             |
+|      3 | 1           |             |
+|      3 | 1           | 1           |
+|      3 | 1           | [2]         |
+|      3 | 1           | [3, [4, 5]] |
+|      3 | 1           |             |
+|      3 | [2]         |             |
+|      3 | [2]         | 1           |
+|      3 | [2]         | [2]         |
+|      3 | [2]         | [3, [4, 5]] |
+|      3 | [2]         |             |
+|      3 | [3, [4, 5]] |             |
+|      3 | [3, [4, 5]] | 1           |
+|      3 | [3, [4, 5]] | [2]         |
+|      3 | [3, [4, 5]] | [3, [4, 5]] |
+|      3 | [3, [4, 5]] |             |
+|      3 |             |             |
+|      3 |             | 1           |
+|      3 |             | [2]         |
+|      3 |             | [3, [4, 5]] |
+|      3 |             |             |
+|      4 |             |             |
+|      4 |             | 1           |
+|      4 |             | [2]         |
+|      4 |             | [3, [4, 5]] |
+|      4 |             |             |
+|      4 | 1           |             |
+|      4 | 1           | 1           |
+|      4 | 1           | [2]         |
+|      4 | 1           | [3, [4, 5]] |
+|      4 | 1           |             |
+|      4 | [2]         |             |
+|      4 | [2]         | 1           |
+|      4 | [2]         | [2]         |
+|      4 | [2]         | [3, [4, 5]] |
+|      4 | [2]         |             |
+|      4 | [3, [4, 5]] |             |
+|      4 | [3, [4, 5]] | 1           |
+|      4 | [3, [4, 5]] | [2]         |
+|      4 | [3, [4, 5]] | [3, [4, 5]] |
+|      4 | [3, [4, 5]] |             |
+|      4 |             |             |
+|      4 |             | 1           |
+|      4 |             | [2]         |
+|      4 |             | [3, [4, 5]] |
+|      4 |             |             |
++--------+-------------+-------------+
+(125 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A3_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c1,
+       c2
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u1(c1)), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN ('',
+                 '1',
+                 '[2]',
+                 '[3, [4, 5]]'))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+-------------+-------------+
+| c_long | c1          | c2          |
++--------+-------------+-------------+
+|      0 |             |             |
+|      0 |             | 1           |
+|      0 |             | [2]         |
+|      0 |             | [3, [4, 5]] |
+|      0 |             |             |
+|      0 | 1           |             |
+|      0 | 1           | 1           |
+|      0 | 1           | [2]         |
+|      0 | 1           | [3, [4, 5]] |
+|      0 | 1           |             |
+|      0 | [2]         |             |
+|      0 | [2]         | 1           |
+|      0 | [2]         | [2]         |
+|      0 | [2]         | [3, [4, 5]] |
+|      0 | [2]         |             |
+|      0 | [3, [4, 5]] |             |
+|      0 | [3, [4, 5]] | 1           |
+|      0 | [3, [4, 5]] | [2]         |
+|      0 | [3, [4, 5]] | [3, [4, 5]] |
+|      0 | [3, [4, 5]] |             |
+|      0 |             |             |
+|      0 |             | 1           |
+|      0 |             | [2]         |
+|      0 |             | [3, [4, 5]] |
+|      0 |             |             |
+|      1 |             |             |
+|      1 |             | 1           |
+|      1 |             | [2]         |
+|      1 |             | [3, [4, 5]] |
+|      1 |             |             |
+|      1 | 1           |             |
+|      1 | 1           | 1           |
+|      1 | 1           | [2]         |
+|      1 | 1           | [3, [4, 5]] |
+|      1 | 1           |             |
+|      1 | [2]         |             |
+|      1 | [2]         | 1           |
+|      1 | [2]         | [2]         |
+|      1 | [2]         | [3, [4, 5]] |
+|      1 | [2]         |             |
+|      1 | [3, [4, 5]] |             |
+|      1 | [3, [4, 5]] | 1           |
+|      1 | [3, [4, 5]] | [2]         |
+|      1 | [3, [4, 5]] | [3, [4, 5]] |
+|      1 | [3, [4, 5]] |             |
+|      1 |             |             |
+|      1 |             | 1           |
+|      1 |             | [2]         |
+|      1 |             | [3, [4, 5]] |
+|      1 |             |             |
+|      2 |             |             |
+|      2 |             | 1           |
+|      2 |             | [2]         |
+|      2 |             | [3, [4, 5]] |
+|      2 |             |             |
+|      2 | 1           |             |
+|      2 | 1           | 1           |
+|      2 | 1           | [2]         |
+|      2 | 1           | [3, [4, 5]] |
+|      2 | 1           |             |
+|      2 | [2]         |             |
+|      2 | [2]         | 1           |
+|      2 | [2]         | [2]         |
+|      2 | [2]         | [3, [4, 5]] |
+|      2 | [2]         |             |
+|      2 | [3, [4, 5]] |             |
+|      2 | [3, [4, 5]] | 1           |
+|      2 | [3, [4, 5]] | [2]         |
+|      2 | [3, [4, 5]] | [3, [4, 5]] |
+|      2 | [3, [4, 5]] |             |
+|      2 |             |             |
+|      2 |             | 1           |
+|      2 |             | [2]         |
+|      2 |             | [3, [4, 5]] |
+|      2 |             |             |
+|      3 |             |             |
+|      3 |             | 1           |
+|      3 |             | [2]         |
+|      3 |             | [3, [4, 5]] |
+|      3 |             |             |
+|      3 | 1           |             |
+|      3 | 1           | 1           |
+|      3 | 1           | [2]         |
+|      3 | 1           | [3, [4, 5]] |
+|      3 | 1           |             |
+|      3 | [2]         |             |
+|      3 | [2]         | 1           |
+|      3 | [2]         | [2]         |
+|      3 | [2]         | [3, [4, 5]] |
+|      3 | [2]         |             |
+|      3 | [3, [4, 5]] |             |
+|      3 | [3, [4, 5]] | 1           |
+|      3 | [3, [4, 5]] | [2]         |
+|      3 | [3, [4, 5]] | [3, [4, 5]] |
+|      3 | [3, [4, 5]] |             |
+|      3 |             |             |
+|      3 |             | 1           |
+|      3 |             | [2]         |
+|      3 |             | [3, [4, 5]] |
+|      3 |             |             |
+|      4 |             |             |
+|      4 |             | 1           |
+|      4 |             | [2]         |
+|      4 |             | [3, [4, 5]] |
+|      4 |             |             |
+|      4 | 1           |             |
+|      4 | 1           | 1           |
+|      4 | 1           | [2]         |
+|      4 | 1           | [3, [4, 5]] |
+|      4 | 1           |             |
+|      4 | [2]         |             |
+|      4 | [2]         | 1           |
+|      4 | [2]         | [2]         |
+|      4 | [2]         | [3, [4, 5]] |
+|      4 | [2]         |             |
+|      4 | [3, [4, 5]] |             |
+|      4 | [3, [4, 5]] | 1           |
+|      4 | [3, [4, 5]] | [2]         |
+|      4 | [3, [4, 5]] | [3, [4, 5]] |
+|      4 | [3, [4, 5]] |             |
+|      4 |             |             |
+|      4 |             | 1           |
+|      4 |             | [2]         |
+|      4 |             | [3, [4, 5]] |
+|      4 |             |             |
++--------+-------------+-------------+
+(125 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A3_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u1(c1))
+SELECT c_long,
+       c1,
+       c2
+FROM t1,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN ('',
+                 '1',
+                 '[2]',
+                 '[3, [4, 5]]'))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+-------------+-------------+
+| c_long | c1          | c2          |
++--------+-------------+-------------+
+|      0 |             |             |
+|      0 |             | 1           |
+|      0 |             | [2]         |
+|      0 |             | [3, [4, 5]] |
+|      0 |             |             |
+|      0 | 1           |             |
+|      0 | 1           | 1           |
+|      0 | 1           | [2]         |
+|      0 | 1           | [3, [4, 5]] |
+|      0 | 1           |             |
+|      0 | [2]         |             |
+|      0 | [2]         | 1           |
+|      0 | [2]         | [2]         |
+|      0 | [2]         | [3, [4, 5]] |
+|      0 | [2]         |             |
+|      0 | [3, [4, 5]] |             |
+|      0 | [3, [4, 5]] | 1           |
+|      0 | [3, [4, 5]] | [2]         |
+|      0 | [3, [4, 5]] | [3, [4, 5]] |
+|      0 | [3, [4, 5]] |             |
+|      0 |             |             |
+|      0 |             | 1           |
+|      0 |             | [2]         |
+|      0 |             | [3, [4, 5]] |
+|      0 |             |             |
+|      1 |             |             |
+|      1 |             | 1           |
+|      1 |             | [2]         |
+|      1 |             | [3, [4, 5]] |
+|      1 |             |             |
+|      1 | 1           |             |
+|      1 | 1           | 1           |
+|      1 | 1           | [2]         |
+|      1 | 1           | [3, [4, 5]] |
+|      1 | 1           |             |
+|      1 | [2]         |             |
+|      1 | [2]         | 1           |
+|      1 | [2]         | [2]         |
+|      1 | [2]         | [3, [4, 5]] |
+|      1 | [2]         |             |
+|      1 | [3, [4, 5]] |             |
+|      1 | [3, [4, 5]] | 1           |
+|      1 | [3, [4, 5]] | [2]         |
+|      1 | [3, [4, 5]] | [3, [4, 5]] |
+|      1 | [3, [4, 5]] |             |
+|      1 |             |             |
+|      1 |             | 1           |
+|      1 |             | [2]         |
+|      1 |             | [3, [4, 5]] |
+|      1 |             |             |
+|      2 |             |             |
+|      2 |             | 1           |
+|      2 |             | [2]         |
+|      2 |             | [3, [4, 5]] |
+|      2 |             |             |
+|      2 | 1           |             |
+|      2 | 1           | 1           |
+|      2 | 1           | [2]         |
+|      2 | 1           | [3, [4, 5]] |
+|      2 | 1           |             |
+|      2 | [2]         |             |
+|      2 | [2]         | 1           |
+|      2 | [2]         | [2]         |
+|      2 | [2]         | [3, [4, 5]] |
+|      2 | [2]         |             |
+|      2 | [3, [4, 5]] |             |
+|      2 | [3, [4, 5]] | 1           |
+|      2 | [3, [4, 5]] | [2]         |
+|      2 | [3, [4, 5]] | [3, [4, 5]] |
+|      2 | [3, [4, 5]] |             |
+|      2 |             |             |
+|      2 |             | 1           |
+|      2 |             | [2]         |
+|      2 |             | [3, [4, 5]] |
+|      2 |             |             |
+|      3 |             |             |
+|      3 |             | 1           |
+|      3 |             | [2]         |
+|      3 |             | [3, [4, 5]] |
+|      3 |             |             |
+|      3 | 1           |             |
+|      3 | 1           | 1           |
+|      3 | 1           | [2]         |
+|      3 | 1           | [3, [4, 5]] |
+|      3 | 1           |             |
+|      3 | [2]         |             |
+|      3 | [2]         | 1           |
+|      3 | [2]         | [2]         |
+|      3 | [2]         | [3, [4, 5]] |
+|      3 | [2]         |             |
+|      3 | [3, [4, 5]] |             |
+|      3 | [3, [4, 5]] | 1           |
+|      3 | [3, [4, 5]] | [2]         |
+|      3 | [3, [4, 5]] | [3, [4, 5]] |
+|      3 | [3, [4, 5]] |             |
+|      3 |             |             |
+|      3 |             | 1           |
+|      3 |             | [2]         |
+|      3 |             | [3, [4, 5]] |
+|      3 |             |             |
+|      4 |             |             |
+|      4 |             | 1           |
+|      4 |             | [2]         |
+|      4 |             | [3, [4, 5]] |
+|      4 |             |             |
+|      4 | 1           |             |
+|      4 | 1           | 1           |
+|      4 | 1           | [2]         |
+|      4 | 1           | [3, [4, 5]] |
+|      4 | 1           |             |
+|      4 | [2]         |             |
+|      4 | [2]         | 1           |
+|      4 | [2]         | [2]         |
+|      4 | [2]         | [3, [4, 5]] |
+|      4 | [2]         |             |
+|      4 | [3, [4, 5]] |             |
+|      4 | [3, [4, 5]] | 1           |
+|      4 | [3, [4, 5]] | [2]         |
+|      4 | [3, [4, 5]] | [3, [4, 5]] |
+|      4 | [3, [4, 5]] |             |
+|      4 |             |             |
+|      4 |             | 1           |
+|      4 |             | [2]         |
+|      4 |             | [3, [4, 5]] |
+|      4 |             |             |
++--------+-------------+-------------+
+(125 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c1,
+       c2
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u1(c1),
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN ('',
+                 '1',
+                 '2',
+                 '3'))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+----+----+
+| c_long | c1 | c2 |
++--------+----+----+
+|      0 |    |    |
+|      0 |    | 1  |
+|      0 |    | 2  |
+|      0 |    | 3  |
+|      0 |    |    |
+|      0 | 1  |    |
+|      0 | 1  | 1  |
+|      0 | 1  | 2  |
+|      0 | 1  | 3  |
+|      0 | 1  |    |
+|      0 | 2  |    |
+|      0 | 2  | 1  |
+|      0 | 2  | 2  |
+|      0 | 2  | 3  |
+|      0 | 2  |    |
+|      0 | 3  |    |
+|      0 | 3  | 1  |
+|      0 | 3  | 2  |
+|      0 | 3  | 3  |
+|      0 | 3  |    |
+|      0 |    |    |
+|      0 |    | 1  |
+|      0 |    | 2  |
+|      0 |    | 3  |
+|      0 |    |    |
+|      1 |    |    |
+|      1 |    | 1  |
+|      1 |    | 2  |
+|      1 |    | 3  |
+|      1 |    |    |
+|      1 | 1  |    |
+|      1 | 1  | 1  |
+|      1 | 1  | 2  |
+|      1 | 1  | 3  |
+|      1 | 1  |    |
+|      1 | 2  |    |
+|      1 | 2  | 1  |
+|      1 | 2  | 2  |
+|      1 | 2  | 3  |
+|      1 | 2  |    |
+|      1 | 3  |    |
+|      1 | 3  | 1  |
+|      1 | 3  | 2  |
+|      1 | 3  | 3  |
+|      1 | 3  |    |
+|      1 |    |    |
+|      1 |    | 1  |
+|      1 |    | 2  |
+|      1 |    | 3  |
+|      1 |    |    |
+|      2 |    |    |
+|      2 |    | 1  |
+|      2 |    | 2  |
+|      2 |    | 3  |
+|      2 |    |    |
+|      2 | 1  |    |
+|      2 | 1  | 1  |
+|      2 | 1  | 2  |
+|      2 | 1  | 3  |
+|      2 | 1  |    |
+|      2 | 2  |    |
+|      2 | 2  | 1  |
+|      2 | 2  | 2  |
+|      2 | 2  | 3  |
+|      2 | 2  |    |
+|      2 | 3  |    |
+|      2 | 3  | 1  |
+|      2 | 3  | 2  |
+|      2 | 3  | 3  |
+|      2 | 3  |    |
+|      2 |    |    |
+|      2 |    | 1  |
+|      2 |    | 2  |
+|      2 |    | 3  |
+|      2 |    |    |
+|      3 |    |    |
+|      3 |    | 1  |
+|      3 |    | 2  |
+|      3 |    | 3  |
+|      3 |    |    |
+|      3 | 1  |    |
+|      3 | 1  | 1  |
+|      3 | 1  | 2  |
+|      3 | 1  | 3  |
+|      3 | 1  |    |
+|      3 | 2  |    |
+|      3 | 2  | 1  |
+|      3 | 2  | 2  |
+|      3 | 2  | 3  |
+|      3 | 2  |    |
+|      3 | 3  |    |
+|      3 | 3  | 1  |
+|      3 | 3  | 2  |
+|      3 | 3  | 3  |
+|      3 | 3  |    |
+|      3 |    |    |
+|      3 |    | 1  |
+|      3 |    | 2  |
+|      3 |    | 3  |
+|      3 |    |    |
+|      4 |    |    |
+|      4 |    | 1  |
+|      4 |    | 2  |
+|      4 |    | 3  |
+|      4 |    |    |
+|      4 | 1  |    |
+|      4 | 1  | 1  |
+|      4 | 1  | 2  |
+|      4 | 1  | 3  |
+|      4 | 1  |    |
+|      4 | 2  |    |
+|      4 | 2  | 1  |
+|      4 | 2  | 2  |
+|      4 | 2  | 3  |
+|      4 | 2  |    |
+|      4 | 3  |    |
+|      4 | 3  | 1  |
+|      4 | 3  | 2  |
+|      4 | 3  | 3  |
+|      4 | 3  |    |
+|      4 |    |    |
+|      4 |    | 1  |
+|      4 |    | 2  |
+|      4 |    | 3  |
+|      4 |    |    |
++--------+----+----+
+(125 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A4_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c1,
+       c2
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u1(c1)), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN ('',
+                 '1',
+                 '2',
+                 '3'))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+----+----+
+| c_long | c1 | c2 |
++--------+----+----+
+|      0 |    |    |
+|      0 |    | 1  |
+|      0 |    | 2  |
+|      0 |    | 3  |
+|      0 |    |    |
+|      0 | 1  |    |
+|      0 | 1  | 1  |
+|      0 | 1  | 2  |
+|      0 | 1  | 3  |
+|      0 | 1  |    |
+|      0 | 2  |    |
+|      0 | 2  | 1  |
+|      0 | 2  | 2  |
+|      0 | 2  | 3  |
+|      0 | 2  |    |
+|      0 | 3  |    |
+|      0 | 3  | 1  |
+|      0 | 3  | 2  |
+|      0 | 3  | 3  |
+|      0 | 3  |    |
+|      0 |    |    |
+|      0 |    | 1  |
+|      0 |    | 2  |
+|      0 |    | 3  |
+|      0 |    |    |
+|      1 |    |    |
+|      1 |    | 1  |
+|      1 |    | 2  |
+|      1 |    | 3  |
+|      1 |    |    |
+|      1 | 1  |    |
+|      1 | 1  | 1  |
+|      1 | 1  | 2  |
+|      1 | 1  | 3  |
+|      1 | 1  |    |
+|      1 | 2  |    |
+|      1 | 2  | 1  |
+|      1 | 2  | 2  |
+|      1 | 2  | 3  |
+|      1 | 2  |    |
+|      1 | 3  |    |
+|      1 | 3  | 1  |
+|      1 | 3  | 2  |
+|      1 | 3  | 3  |
+|      1 | 3  |    |
+|      1 |    |    |
+|      1 |    | 1  |
+|      1 |    | 2  |
+|      1 |    | 3  |
+|      1 |    |    |
+|      2 |    |    |
+|      2 |    | 1  |
+|      2 |    | 2  |
+|      2 |    | 3  |
+|      2 |    |    |
+|      2 | 1  |    |
+|      2 | 1  | 1  |
+|      2 | 1  | 2  |
+|      2 | 1  | 3  |
+|      2 | 1  |    |
+|      2 | 2  |    |
+|      2 | 2  | 1  |
+|      2 | 2  | 2  |
+|      2 | 2  | 3  |
+|      2 | 2  |    |
+|      2 | 3  |    |
+|      2 | 3  | 1  |
+|      2 | 3  | 2  |
+|      2 | 3  | 3  |
+|      2 | 3  |    |
+|      2 |    |    |
+|      2 |    | 1  |
+|      2 |    | 2  |
+|      2 |    | 3  |
+|      2 |    |    |
+|      3 |    |    |
+|      3 |    | 1  |
+|      3 |    | 2  |
+|      3 |    | 3  |
+|      3 |    |    |
+|      3 | 1  |    |
+|      3 | 1  | 1  |
+|      3 | 1  | 2  |
+|      3 | 1  | 3  |
+|      3 | 1  |    |
+|      3 | 2  |    |
+|      3 | 2  | 1  |
+|      3 | 2  | 2  |
+|      3 | 2  | 3  |
+|      3 | 2  |    |
+|      3 | 3  |    |
+|      3 | 3  | 1  |
+|      3 | 3  | 2  |
+|      3 | 3  | 3  |
+|      3 | 3  |    |
+|      3 |    |    |
+|      3 |    | 1  |
+|      3 |    | 2  |
+|      3 |    | 3  |
+|      3 |    |    |
+|      4 |    |    |
+|      4 |    | 1  |
+|      4 |    | 2  |
+|      4 |    | 3  |
+|      4 |    |    |
+|      4 | 1  |    |
+|      4 | 1  | 1  |
+|      4 | 1  | 2  |
+|      4 | 1  | 3  |
+|      4 | 1  |    |
+|      4 | 2  |    |
+|      4 | 2  | 1  |
+|      4 | 2  | 2  |
+|      4 | 2  | 3  |
+|      4 | 2  |    |
+|      4 | 3  |    |
+|      4 | 3  | 1  |
+|      4 | 3  | 2  |
+|      4 | 3  | 3  |
+|      4 | 3  |    |
+|      4 |    |    |
+|      4 |    | 1  |
+|      4 |    | 2  |
+|      4 |    | 3  |
+|      4 |    |    |
++--------+----+----+
+(125 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A4_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u1(c1))
+SELECT c_long,
+       c1,
+       c2
+FROM t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN ('',
+                 '1',
+                 '2',
+                 '3'))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+----+----+
+| c_long | c1 | c2 |
++--------+----+----+
+|      0 |    |    |
+|      0 |    | 1  |
+|      0 |    | 2  |
+|      0 |    | 3  |
+|      0 |    |    |
+|      0 | 1  |    |
+|      0 | 1  | 1  |
+|      0 | 1  | 2  |
+|      0 | 1  | 3  |
+|      0 | 1  |    |
+|      0 | 2  |    |
+|      0 | 2  | 1  |
+|      0 | 2  | 2  |
+|      0 | 2  | 3  |
+|      0 | 2  |    |
+|      0 | 3  |    |
+|      0 | 3  | 1  |
+|      0 | 3  | 2  |
+|      0 | 3  | 3  |
+|      0 | 3  |    |
+|      0 |    |    |
+|      0 |    | 1  |
+|      0 |    | 2  |
+|      0 |    | 3  |
+|      0 |    |    |
+|      1 |    |    |
+|      1 |    | 1  |
+|      1 |    | 2  |
+|      1 |    | 3  |
+|      1 |    |    |
+|      1 | 1  |    |
+|      1 | 1  | 1  |
+|      1 | 1  | 2  |
+|      1 | 1  | 3  |
+|      1 | 1  |    |
+|      1 | 2  |    |
+|      1 | 2  | 1  |
+|      1 | 2  | 2  |
+|      1 | 2  | 3  |
+|      1 | 2  |    |
+|      1 | 3  |    |
+|      1 | 3  | 1  |
+|      1 | 3  | 2  |
+|      1 | 3  | 3  |
+|      1 | 3  |    |
+|      1 |    |    |
+|      1 |    | 1  |
+|      1 |    | 2  |
+|      1 |    | 3  |
+|      1 |    |    |
+|      2 |    |    |
+|      2 |    | 1  |
+|      2 |    | 2  |
+|      2 |    | 3  |
+|      2 |    |    |
+|      2 | 1  |    |
+|      2 | 1  | 1  |
+|      2 | 1  | 2  |
+|      2 | 1  | 3  |
+|      2 | 1  |    |
+|      2 | 2  |    |
+|      2 | 2  | 1  |
+|      2 | 2  | 2  |
+|      2 | 2  | 3  |
+|      2 | 2  |    |
+|      2 | 3  |    |
+|      2 | 3  | 1  |
+|      2 | 3  | 2  |
+|      2 | 3  | 3  |
+|      2 | 3  |    |
+|      2 |    |    |
+|      2 |    | 1  |
+|      2 |    | 2  |
+|      2 |    | 3  |
+|      2 |    |    |
+|      3 |    |    |
+|      3 |    | 1  |
+|      3 |    | 2  |
+|      3 |    | 3  |
+|      3 |    |    |
+|      3 | 1  |    |
+|      3 | 1  | 1  |
+|      3 | 1  | 2  |
+|      3 | 1  | 3  |
+|      3 | 1  |    |
+|      3 | 2  |    |
+|      3 | 2  | 1  |
+|      3 | 2  | 2  |
+|      3 | 2  | 3  |
+|      3 | 2  |    |
+|      3 | 3  |    |
+|      3 | 3  | 1  |
+|      3 | 3  | 2  |
+|      3 | 3  | 3  |
+|      3 | 3  |    |
+|      3 |    |    |
+|      3 |    | 1  |
+|      3 |    | 2  |
+|      3 |    | 3  |
+|      3 |    |    |
+|      4 |    |    |
+|      4 |    | 1  |
+|      4 |    | 2  |
+|      4 |    | 3  |
+|      4 |    |    |
+|      4 | 1  |    |
+|      4 | 1  | 1  |
+|      4 | 1  | 2  |
+|      4 | 1  | 3  |
+|      4 | 1  |    |
+|      4 | 2  |    |
+|      4 | 2  | 1  |
+|      4 | 2  | 2  |
+|      4 | 2  | 3  |
+|      4 | 2  |    |
+|      4 | 3  |    |
+|      4 | 3  | 1  |
+|      4 | 3  | 2  |
+|      4 | 3  | 3  |
+|      4 | 3  |    |
+|      4 |    |    |
+|      4 |    | 1  |
+|      4 |    | 2  |
+|      4 |    | 3  |
+|      4 |    |    |
++--------+----+----+
+(125 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c1,
+       c2
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u1(c1),
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN ('',
+                 '1',
+                 '[2]',
+                 '[3, [4, 5]]'))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+-------------+-------------+
+| c_long | c1          | c2          |
++--------+-------------+-------------+
+|      0 |             |             |
+|      1 |             |             |
+|      2 |             |             |
+|      2 |             | 1           |
+|      2 |             | [2]         |
+|      2 |             | [3, [4, 5]] |
+|      2 |             |             |
+|      2 | 1           |             |
+|      2 | 1           | 1           |
+|      2 | 1           | [2]         |
+|      2 | 1           | [3, [4, 5]] |
+|      2 | 1           |             |
+|      2 | [2]         |             |
+|      2 | [2]         | 1           |
+|      2 | [2]         | [2]         |
+|      2 | [2]         | [3, [4, 5]] |
+|      2 | [2]         |             |
+|      2 | [3, [4, 5]] |             |
+|      2 | [3, [4, 5]] | 1           |
+|      2 | [3, [4, 5]] | [2]         |
+|      2 | [3, [4, 5]] | [3, [4, 5]] |
+|      2 | [3, [4, 5]] |             |
+|      2 |             |             |
+|      2 |             | 1           |
+|      2 |             | [2]         |
+|      2 |             | [3, [4, 5]] |
+|      2 |             |             |
+|      3 |             |             |
+|      3 |             | 1           |
+|      3 |             | [2]         |
+|      3 |             | [3, [4, 5]] |
+|      3 |             |             |
+|      3 | 1           |             |
+|      3 | 1           | 1           |
+|      3 | 1           | [2]         |
+|      3 | 1           | [3, [4, 5]] |
+|      3 | 1           |             |
+|      3 | [2]         |             |
+|      3 | [2]         | 1           |
+|      3 | [2]         | [2]         |
+|      3 | [2]         | [3, [4, 5]] |
+|      3 | [2]         |             |
+|      3 | [3, [4, 5]] |             |
+|      3 | [3, [4, 5]] | 1           |
+|      3 | [3, [4, 5]] | [2]         |
+|      3 | [3, [4, 5]] | [3, [4, 5]] |
+|      3 | [3, [4, 5]] |             |
+|      3 |             |             |
+|      3 |             | 1           |
+|      3 |             | [2]         |
+|      3 |             | [3, [4, 5]] |
+|      3 |             |             |
+|      4 |             |             |
+|      4 |             | 1           |
+|      4 |             | [2]         |
+|      4 |             | [3, [4, 5]] |
+|      4 |             |             |
+|      4 | 1           |             |
+|      4 | 1           | 1           |
+|      4 | 1           | [2]         |
+|      4 | 1           | [3, [4, 5]] |
+|      4 | 1           |             |
+|      4 | [2]         |             |
+|      4 | [2]         | 1           |
+|      4 | [2]         | [2]         |
+|      4 | [2]         | [3, [4, 5]] |
+|      4 | [2]         |             |
+|      4 | [3, [4, 5]] |             |
+|      4 | [3, [4, 5]] | 1           |
+|      4 | [3, [4, 5]] | [2]         |
+|      4 | [3, [4, 5]] | [3, [4, 5]] |
+|      4 | [3, [4, 5]] |             |
+|      4 |             |             |
+|      4 |             | 1           |
+|      4 |             | [2]         |
+|      4 |             | [3, [4, 5]] |
+|      4 |             |             |
++--------+-------------+-------------+
+(77 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A5_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c1,
+       c2
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u1(c1)), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN ('',
+                 '1',
+                 '[2]',
+                 '[3, [4, 5]]'))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+-------------+-------------+
+| c_long | c1          | c2          |
++--------+-------------+-------------+
+|      0 |             |             |
+|      1 |             |             |
+|      2 |             |             |
+|      2 |             | 1           |
+|      2 |             | [2]         |
+|      2 |             | [3, [4, 5]] |
+|      2 |             |             |
+|      2 | 1           |             |
+|      2 | 1           | 1           |
+|      2 | 1           | [2]         |
+|      2 | 1           | [3, [4, 5]] |
+|      2 | 1           |             |
+|      2 | [2]         |             |
+|      2 | [2]         | 1           |
+|      2 | [2]         | [2]         |
+|      2 | [2]         | [3, [4, 5]] |
+|      2 | [2]         |             |
+|      2 | [3, [4, 5]] |             |
+|      2 | [3, [4, 5]] | 1           |
+|      2 | [3, [4, 5]] | [2]         |
+|      2 | [3, [4, 5]] | [3, [4, 5]] |
+|      2 | [3, [4, 5]] |             |
+|      2 |             |             |
+|      2 |             | 1           |
+|      2 |             | [2]         |
+|      2 |             | [3, [4, 5]] |
+|      2 |             |             |
+|      3 |             |             |
+|      3 |             | 1           |
+|      3 |             | [2]         |
+|      3 |             | [3, [4, 5]] |
+|      3 |             |             |
+|      3 | 1           |             |
+|      3 | 1           | 1           |
+|      3 | 1           | [2]         |
+|      3 | 1           | [3, [4, 5]] |
+|      3 | 1           |             |
+|      3 | [2]         |             |
+|      3 | [2]         | 1           |
+|      3 | [2]         | [2]         |
+|      3 | [2]         | [3, [4, 5]] |
+|      3 | [2]         |             |
+|      3 | [3, [4, 5]] |             |
+|      3 | [3, [4, 5]] | 1           |
+|      3 | [3, [4, 5]] | [2]         |
+|      3 | [3, [4, 5]] | [3, [4, 5]] |
+|      3 | [3, [4, 5]] |             |
+|      3 |             |             |
+|      3 |             | 1           |
+|      3 |             | [2]         |
+|      3 |             | [3, [4, 5]] |
+|      3 |             |             |
+|      4 |             |             |
+|      4 |             | 1           |
+|      4 |             | [2]         |
+|      4 |             | [3, [4, 5]] |
+|      4 |             |             |
+|      4 | 1           |             |
+|      4 | 1           | 1           |
+|      4 | 1           | [2]         |
+|      4 | 1           | [3, [4, 5]] |
+|      4 | 1           |             |
+|      4 | [2]         |             |
+|      4 | [2]         | 1           |
+|      4 | [2]         | [2]         |
+|      4 | [2]         | [3, [4, 5]] |
+|      4 | [2]         |             |
+|      4 | [3, [4, 5]] |             |
+|      4 | [3, [4, 5]] | 1           |
+|      4 | [3, [4, 5]] | [2]         |
+|      4 | [3, [4, 5]] | [3, [4, 5]] |
+|      4 | [3, [4, 5]] |             |
+|      4 |             |             |
+|      4 |             | 1           |
+|      4 |             | [2]         |
+|      4 |             | [3, [4, 5]] |
+|      4 |             |             |
++--------+-------------+-------------+
+(77 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A5_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u1(c1))
+SELECT c_long,
+       c1,
+       c2
+FROM t1,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN ('',
+                 '1',
+                 '[2]',
+                 '[3, [4, 5]]'))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+-------------+-------------+
+| c_long | c1          | c2          |
++--------+-------------+-------------+
+|      0 |             |             |
+|      1 |             |             |
+|      2 |             |             |
+|      2 |             | 1           |
+|      2 |             | [2]         |
+|      2 |             | [3, [4, 5]] |
+|      2 |             |             |
+|      2 | 1           |             |
+|      2 | 1           | 1           |
+|      2 | 1           | [2]         |
+|      2 | 1           | [3, [4, 5]] |
+|      2 | 1           |             |
+|      2 | [2]         |             |
+|      2 | [2]         | 1           |
+|      2 | [2]         | [2]         |
+|      2 | [2]         | [3, [4, 5]] |
+|      2 | [2]         |             |
+|      2 | [3, [4, 5]] |             |
+|      2 | [3, [4, 5]] | 1           |
+|      2 | [3, [4, 5]] | [2]         |
+|      2 | [3, [4, 5]] | [3, [4, 5]] |
+|      2 | [3, [4, 5]] |             |
+|      2 |             |             |
+|      2 |             | 1           |
+|      2 |             | [2]         |
+|      2 |             | [3, [4, 5]] |
+|      2 |             |             |
+|      3 |             |             |
+|      3 |             | 1           |
+|      3 |             | [2]         |
+|      3 |             | [3, [4, 5]] |
+|      3 |             |             |
+|      3 | 1           |             |
+|      3 | 1           | 1           |
+|      3 | 1           | [2]         |
+|      3 | 1           | [3, [4, 5]] |
+|      3 | 1           |             |
+|      3 | [2]         |             |
+|      3 | [2]         | 1           |
+|      3 | [2]         | [2]         |
+|      3 | [2]         | [3, [4, 5]] |
+|      3 | [2]         |             |
+|      3 | [3, [4, 5]] |             |
+|      3 | [3, [4, 5]] | 1           |
+|      3 | [3, [4, 5]] | [2]         |
+|      3 | [3, [4, 5]] | [3, [4, 5]] |
+|      3 | [3, [4, 5]] |             |
+|      3 |             |             |
+|      3 |             | 1           |
+|      3 |             | [2]         |
+|      3 |             | [3, [4, 5]] |
+|      3 |             |             |
+|      4 |             |             |
+|      4 |             | 1           |
+|      4 |             | [2]         |
+|      4 |             | [3, [4, 5]] |
+|      4 |             |             |
+|      4 | 1           |             |
+|      4 | 1           | 1           |
+|      4 | 1           | [2]         |
+|      4 | 1           | [3, [4, 5]] |
+|      4 | 1           |             |
+|      4 | [2]         |             |
+|      4 | [2]         | 1           |
+|      4 | [2]         | [2]         |
+|      4 | [2]         | [3, [4, 5]] |
+|      4 | [2]         |             |
+|      4 | [3, [4, 5]] |             |
+|      4 | [3, [4, 5]] | 1           |
+|      4 | [3, [4, 5]] | [2]         |
+|      4 | [3, [4, 5]] | [3, [4, 5]] |
+|      4 | [3, [4, 5]] |             |
+|      4 |             |             |
+|      4 |             | 1           |
+|      4 |             | [2]         |
+|      4 |             | [3, [4, 5]] |
+|      4 |             |             |
++--------+-------------+-------------+
+(77 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c1,
+       c2
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u1(c1),
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN ('',
+                 '1',
+                 '2',
+                 '3'))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+----+----+
+| c_long | c1 | c2 |
++--------+----+----+
+|      0 |    |    |
+|      1 |    |    |
+|      2 |    |    |
+|      2 |    | 1  |
+|      2 |    | 2  |
+|      2 |    | 3  |
+|      2 |    |    |
+|      2 | 1  |    |
+|      2 | 1  | 1  |
+|      2 | 1  | 2  |
+|      2 | 1  | 3  |
+|      2 | 1  |    |
+|      2 | 2  |    |
+|      2 | 2  | 1  |
+|      2 | 2  | 2  |
+|      2 | 2  | 3  |
+|      2 | 2  |    |
+|      2 | 3  |    |
+|      2 | 3  | 1  |
+|      2 | 3  | 2  |
+|      2 | 3  | 3  |
+|      2 | 3  |    |
+|      2 |    |    |
+|      2 |    | 1  |
+|      2 |    | 2  |
+|      2 |    | 3  |
+|      2 |    |    |
+|      3 |    |    |
+|      3 |    | 1  |
+|      3 |    | 2  |
+|      3 |    | 3  |
+|      3 |    |    |
+|      3 | 1  |    |
+|      3 | 1  | 1  |
+|      3 | 1  | 2  |
+|      3 | 1  | 3  |
+|      3 | 1  |    |
+|      3 | 2  |    |
+|      3 | 2  | 1  |
+|      3 | 2  | 2  |
+|      3 | 2  | 3  |
+|      3 | 2  |    |
+|      3 | 3  |    |
+|      3 | 3  | 1  |
+|      3 | 3  | 2  |
+|      3 | 3  | 3  |
+|      3 | 3  |    |
+|      3 |    |    |
+|      3 |    | 1  |
+|      3 |    | 2  |
+|      3 |    | 3  |
+|      3 |    |    |
+|      4 |    |    |
+|      4 |    | 1  |
+|      4 |    | 2  |
+|      4 |    | 3  |
+|      4 |    |    |
+|      4 | 1  |    |
+|      4 | 1  | 1  |
+|      4 | 1  | 2  |
+|      4 | 1  | 3  |
+|      4 | 1  |    |
+|      4 | 2  |    |
+|      4 | 2  | 1  |
+|      4 | 2  | 2  |
+|      4 | 2  | 3  |
+|      4 | 2  |    |
+|      4 | 3  |    |
+|      4 | 3  | 1  |
+|      4 | 3  | 2  |
+|      4 | 3  | 3  |
+|      4 | 3  |    |
+|      4 |    |    |
+|      4 |    | 1  |
+|      4 |    | 2  |
+|      4 |    | 3  |
+|      4 |    |    |
++--------+----+----+
+(77 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A6_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c1,
+       c2
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u1(c1)), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN ('',
+                 '1',
+                 '2',
+                 '3'))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+----+----+
+| c_long | c1 | c2 |
++--------+----+----+
+|      0 |    |    |
+|      1 |    |    |
+|      2 |    |    |
+|      2 |    | 1  |
+|      2 |    | 2  |
+|      2 |    | 3  |
+|      2 |    |    |
+|      2 | 1  |    |
+|      2 | 1  | 1  |
+|      2 | 1  | 2  |
+|      2 | 1  | 3  |
+|      2 | 1  |    |
+|      2 | 2  |    |
+|      2 | 2  | 1  |
+|      2 | 2  | 2  |
+|      2 | 2  | 3  |
+|      2 | 2  |    |
+|      2 | 3  |    |
+|      2 | 3  | 1  |
+|      2 | 3  | 2  |
+|      2 | 3  | 3  |
+|      2 | 3  |    |
+|      2 |    |    |
+|      2 |    | 1  |
+|      2 |    | 2  |
+|      2 |    | 3  |
+|      2 |    |    |
+|      3 |    |    |
+|      3 |    | 1  |
+|      3 |    | 2  |
+|      3 |    | 3  |
+|      3 |    |    |
+|      3 | 1  |    |
+|      3 | 1  | 1  |
+|      3 | 1  | 2  |
+|      3 | 1  | 3  |
+|      3 | 1  |    |
+|      3 | 2  |    |
+|      3 | 2  | 1  |
+|      3 | 2  | 2  |
+|      3 | 2  | 3  |
+|      3 | 2  |    |
+|      3 | 3  |    |
+|      3 | 3  | 1  |
+|      3 | 3  | 2  |
+|      3 | 3  | 3  |
+|      3 | 3  |    |
+|      3 |    |    |
+|      3 |    | 1  |
+|      3 |    | 2  |
+|      3 |    | 3  |
+|      3 |    |    |
+|      4 |    |    |
+|      4 |    | 1  |
+|      4 |    | 2  |
+|      4 |    | 3  |
+|      4 |    |    |
+|      4 | 1  |    |
+|      4 | 1  | 1  |
+|      4 | 1  | 2  |
+|      4 | 1  | 3  |
+|      4 | 1  |    |
+|      4 | 2  |    |
+|      4 | 2  | 1  |
+|      4 | 2  | 2  |
+|      4 | 2  | 3  |
+|      4 | 2  |    |
+|      4 | 3  |    |
+|      4 | 3  | 1  |
+|      4 | 3  | 2  |
+|      4 | 3  | 3  |
+|      4 | 3  |    |
+|      4 |    |    |
+|      4 |    | 1  |
+|      4 |    | 2  |
+|      4 |    | 3  |
+|      4 |    |    |
++--------+----+----+
+(77 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A6_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u1(c1))
+SELECT c_long,
+       c1,
+       c2
+FROM t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN ('',
+                 '1',
+                 '2',
+                 '3'))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+----+----+
+| c_long | c1 | c2 |
++--------+----+----+
+|      0 |    |    |
+|      1 |    |    |
+|      2 |    |    |
+|      2 |    | 1  |
+|      2 |    | 2  |
+|      2 |    | 3  |
+|      2 |    |    |
+|      2 | 1  |    |
+|      2 | 1  | 1  |
+|      2 | 1  | 2  |
+|      2 | 1  | 3  |
+|      2 | 1  |    |
+|      2 | 2  |    |
+|      2 | 2  | 1  |
+|      2 | 2  | 2  |
+|      2 | 2  | 3  |
+|      2 | 2  |    |
+|      2 | 3  |    |
+|      2 | 3  | 1  |
+|      2 | 3  | 2  |
+|      2 | 3  | 3  |
+|      2 | 3  |    |
+|      2 |    |    |
+|      2 |    | 1  |
+|      2 |    | 2  |
+|      2 |    | 3  |
+|      2 |    |    |
+|      3 |    |    |
+|      3 |    | 1  |
+|      3 |    | 2  |
+|      3 |    | 3  |
+|      3 |    |    |
+|      3 | 1  |    |
+|      3 | 1  | 1  |
+|      3 | 1  | 2  |
+|      3 | 1  | 3  |
+|      3 | 1  |    |
+|      3 | 2  |    |
+|      3 | 2  | 1  |
+|      3 | 2  | 2  |
+|      3 | 2  | 3  |
+|      3 | 2  |    |
+|      3 | 3  |    |
+|      3 | 3  | 1  |
+|      3 | 3  | 2  |
+|      3 | 3  | 3  |
+|      3 | 3  |    |
+|      3 |    |    |
+|      3 |    | 1  |
+|      3 |    | 2  |
+|      3 |    | 3  |
+|      3 |    |    |
+|      4 |    |    |
+|      4 |    | 1  |
+|      4 |    | 2  |
+|      4 |    | 3  |
+|      4 |    |    |
+|      4 | 1  |    |
+|      4 | 1  | 1  |
+|      4 | 1  | 2  |
+|      4 | 1  | 3  |
+|      4 | 1  |    |
+|      4 | 2  |    |
+|      4 | 2  | 1  |
+|      4 | 2  | 2  |
+|      4 | 2  | 3  |
+|      4 | 2  |    |
+|      4 | 3  |    |
+|      4 | 3  | 1  |
+|      4 | 3  | 2  |
+|      4 | 3  | 3  |
+|      4 | 3  |    |
+|      4 |    |    |
+|      4 |    | 1  |
+|      4 |    | 2  |
+|      4 |    | 3  |
+|      4 |    |    |
++--------+----+----+
+(77 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c1,
+       c2
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u1(c1),
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN (''))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+----+----+
+| c_long | c1 | c2 |
++--------+----+----+
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
++--------+----+----+
+(125 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A7_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c1,
+       c2
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u1(c1)), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN (''))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+----+----+
+| c_long | c1 | c2 |
++--------+----+----+
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
++--------+----+----+
+(125 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_multi_unnests TEST_ID: A7_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u1(c1))
+SELECT c_long,
+       c1,
+       c2
+FROM t1,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u2(c2)
+WHERE (c1 IS NULL
+       OR c1 IN (''))
+  AND (c2 IS NULL
+       OR c2 NOT IN ('doesntexist1',
+                     'doesntexist2'))
+  AND c_long>=0;
++--------+----+----+
+| c_long | c1 | c2 |
++--------+----+----+
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      0 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      1 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      2 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      3 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
+|      4 |    |    |
++--------+----+----+
+(125 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_mv_complex,
+       count(*) cnt
+FROM test_unnest
+GROUP BY c_mv_complex;
++--------------+-----+
+| c_mv_complex | cnt |
++--------------+-----+
+| 1            |   5 |
+| [2]          |   5 |
+| [3, [4, 5]]  |   5 |
+| my_empty     |   5 |
+| my_null      |   5 |
++--------------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY c;
++-------------+-----+
+| c           | cnt |
++-------------+-----+
+| 1           |   5 |
+| [2]         |   5 |
+| [3, [4, 5]] |   5 |
+| my_empty    |   5 |
+| my_null     |   5 |
++-------------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY c_str,
+         c;
++-------+-------------+-----+
+| c_str | c           | cnt |
++-------+-------------+-----+
+|       | 1           |   1 |
+|       | [2]         |   1 |
+|       | [3, [4, 5]] |   1 |
+|       | my_empty    |   1 |
+|       | my_null     |   1 |
+| str2  | 1           |   1 |
+| str2  | [2]         |   1 |
+| str2  | [3, [4, 5]] |   1 |
+| str2  | my_empty    |   1 |
+| str2  | my_null     |   1 |
+| str3  | 1           |   1 |
+| str3  | [2]         |   1 |
+| str3  | [3, [4, 5]] |   1 |
+| str3  | my_empty    |   1 |
+| str3  | my_null     |   1 |
+| str4  | 1           |   1 |
+| str4  | [2]         |   1 |
+| str4  | [3, [4, 5]] |   1 |
+| str4  | my_empty    |   1 |
+| str4  | my_null     |   1 |
+|       | 1           |   1 |
+|       | [2]         |   1 |
+|       | [3, [4, 5]] |   1 |
+|       | my_empty    |   1 |
+|       | my_null     |   1 |
++-------+-------------+-----+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY c_str;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY GROUPING
+SETS (c);
++-------------+-----+
+| c           | cnt |
++-------------+-----+
+| 1           |   5 |
+| [2]         |   5 |
+| [3, [4, 5]] |   5 |
+| my_empty    |   5 |
+| my_null     |   5 |
++-------------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY GROUPING
+SETS (c_str,
+      c);
++-------+-------------+-----+
+| c_str | c           | cnt |
++-------+-------------+-----+
+|       |             |   5 |
+| str2  |             |   5 |
+| str3  |             |   5 |
+| str4  |             |   5 |
+|       | 1           |   5 |
+|       | [2]         |   5 |
+|       | [3, [4, 5]] |   5 |
+|       | my_empty    |   5 |
+|       | my_null     |   5 |
+|       |             |   5 |
++-------+-------------+-----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY GROUPING
+SETS (c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY rollup(c);
++-------------+-----+
+| c           | cnt |
++-------------+-----+
+| 1           |   5 |
+| [2]         |   5 |
+| [3, [4, 5]] |   5 |
+| my_empty    |   5 |
+| my_null     |   5 |
+|             |  25 |
++-------------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY rollup(c_str, c);
++-------+-------------+-----+
+| c_str | c           | cnt |
++-------+-------------+-----+
+|       | 1           |   1 |
+|       | [2]         |   1 |
+|       | [3, [4, 5]] |   1 |
+|       | my_empty    |   1 |
+|       | my_null     |   1 |
+|       |             |   5 |
+| str2  | 1           |   1 |
+| str2  | [2]         |   1 |
+| str2  | [3, [4, 5]] |   1 |
+| str2  | my_empty    |   1 |
+| str2  | my_null     |   1 |
+| str2  |             |   5 |
+| str3  | 1           |   1 |
+| str3  | [2]         |   1 |
+| str3  | [3, [4, 5]] |   1 |
+| str3  | my_empty    |   1 |
+| str3  | my_null     |   1 |
+| str3  |             |   5 |
+| str4  | 1           |   1 |
+| str4  | [2]         |   1 |
+| str4  | [3, [4, 5]] |   1 |
+| str4  | my_empty    |   1 |
+| str4  | my_null     |   1 |
+| str4  |             |   5 |
+|       | 1           |   1 |
+|       | [2]         |   1 |
+|       | [3, [4, 5]] |   1 |
+|       | my_empty    |   1 |
+|       | my_null     |   1 |
+|       |             |  25 |
+|       |             |   5 |
++-------+-------------+-----+
+(31 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY rollup(c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |  25 |
+|       |   5 |
++-------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY cube(c);
++-------------+-----+
+| c           | cnt |
++-------------+-----+
+| 1           |   5 |
+| [2]         |   5 |
+| [3, [4, 5]] |   5 |
+| my_empty    |   5 |
+| my_null     |   5 |
+|             |  25 |
++-------------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY cube(c_str, c);
++-------+-------------+-----+
+| c_str | c           | cnt |
++-------+-------------+-----+
+|       | 1           |   1 |
+|       | [2]         |   1 |
+|       | [3, [4, 5]] |   1 |
+|       | my_empty    |   1 |
+|       | my_null     |   1 |
+|       |             |   5 |
+| str2  | 1           |   1 |
+| str2  | [2]         |   1 |
+| str2  | [3, [4, 5]] |   1 |
+| str2  | my_empty    |   1 |
+| str2  | my_null     |   1 |
+| str2  |             |   5 |
+| str3  | 1           |   1 |
+| str3  | [2]         |   1 |
+| str3  | [3, [4, 5]] |   1 |
+| str3  | my_empty    |   1 |
+| str3  | my_null     |   1 |
+| str3  |             |   5 |
+| str4  | 1           |   1 |
+| str4  | [2]         |   1 |
+| str4  | [3, [4, 5]] |   1 |
+| str4  | my_empty    |   1 |
+| str4  | my_null     |   1 |
+| str4  |             |   5 |
+|       | 1           |   1 |
+|       | 1           |   5 |
+|       | [2]         |   1 |
+|       | [2]         |   5 |
+|       | [3, [4, 5]] |   1 |
+|       | [3, [4, 5]] |   5 |
+|       | my_empty    |   1 |
+|       | my_empty    |   5 |
+|       | my_null     |   1 |
+|       | my_null     |   5 |
+|       |             |  25 |
+|       |             |   5 |
++-------+-------------+-----+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY cube(c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |  25 |
+|       |   5 |
++-------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY c
+HAVING c='1';
++---+-----+
+| c | cnt |
++---+-----+
+| 1 |   5 |
++---+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY c_str
+HAVING c_str='str2';
++-------+-----+
+| c_str | cnt |
++-------+-----+
+| str2  |   5 |
++-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_mv_num,
+       count(*) cnt
+FROM test_unnest
+GROUP BY c_mv_num;
++----------+-----+
+| c_mv_num | cnt |
++----------+-----+
+| -1       |   5 |
+| 0        |   5 |
+| 1        |   5 |
+| 2        |   5 |
+| 3        |   5 |
++----------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY c;
++----+-----+
+| c  | cnt |
++----+-----+
+| -1 |   5 |
+| 0  |   5 |
+| 1  |   5 |
+| 2  |   5 |
+| 3  |   5 |
++----+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY c_str,
+         c;
++-------+----+-----+
+| c_str | c  | cnt |
++-------+----+-----+
+|       | -1 |   1 |
+|       | 0  |   1 |
+|       | 1  |   1 |
+|       | 2  |   1 |
+|       | 3  |   1 |
+| str2  | -1 |   1 |
+| str2  | 0  |   1 |
+| str2  | 1  |   1 |
+| str2  | 2  |   1 |
+| str2  | 3  |   1 |
+| str3  | -1 |   1 |
+| str3  | 0  |   1 |
+| str3  | 1  |   1 |
+| str3  | 2  |   1 |
+| str3  | 3  |   1 |
+| str4  | -1 |   1 |
+| str4  | 0  |   1 |
+| str4  | 1  |   1 |
+| str4  | 2  |   1 |
+| str4  | 3  |   1 |
+|       | -1 |   1 |
+|       | 0  |   1 |
+|       | 1  |   1 |
+|       | 2  |   1 |
+|       | 3  |   1 |
++-------+----+-----+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY c_str;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY GROUPING
+SETS (c);
++----+-----+
+| c  | cnt |
++----+-----+
+| -1 |   5 |
+| 0  |   5 |
+| 1  |   5 |
+| 2  |   5 |
+| 3  |   5 |
++----+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY GROUPING
+SETS (c_str,
+      c);
++-------+----+-----+
+| c_str | c  | cnt |
++-------+----+-----+
+|       |    |   5 |
+| str2  |    |   5 |
+| str3  |    |   5 |
+| str4  |    |   5 |
+|       | -1 |   5 |
+|       | 0  |   5 |
+|       | 1  |   5 |
+|       | 2  |   5 |
+|       | 3  |   5 |
+|       |    |   5 |
++-------+----+-----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY GROUPING
+SETS (c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY rollup(c);
++----+-----+
+| c  | cnt |
++----+-----+
+| -1 |   5 |
+| 0  |   5 |
+| 1  |   5 |
+| 2  |   5 |
+| 3  |   5 |
+|    |  25 |
++----+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY rollup(c_str, c);
++-------+----+-----+
+| c_str | c  | cnt |
++-------+----+-----+
+|       | -1 |   1 |
+|       | 0  |   1 |
+|       | 1  |   1 |
+|       | 2  |   1 |
+|       | 3  |   1 |
+|       |    |   5 |
+| str2  | -1 |   1 |
+| str2  | 0  |   1 |
+| str2  | 1  |   1 |
+| str2  | 2  |   1 |
+| str2  | 3  |   1 |
+| str2  |    |   5 |
+| str3  | -1 |   1 |
+| str3  | 0  |   1 |
+| str3  | 1  |   1 |
+| str3  | 2  |   1 |
+| str3  | 3  |   1 |
+| str3  |    |   5 |
+| str4  | -1 |   1 |
+| str4  | 0  |   1 |
+| str4  | 1  |   1 |
+| str4  | 2  |   1 |
+| str4  | 3  |   1 |
+| str4  |    |   5 |
+|       | -1 |   1 |
+|       | 0  |   1 |
+|       | 1  |   1 |
+|       | 2  |   1 |
+|       | 3  |   1 |
+|       |    |  25 |
+|       |    |   5 |
++-------+----+-----+
+(31 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY rollup(c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |  25 |
+|       |   5 |
++-------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY cube(c);
++----+-----+
+| c  | cnt |
++----+-----+
+| -1 |   5 |
+| 0  |   5 |
+| 1  |   5 |
+| 2  |   5 |
+| 3  |   5 |
+|    |  25 |
++----+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY cube(c_str, c);
++-------+----+-----+
+| c_str | c  | cnt |
++-------+----+-----+
+|       | -1 |   1 |
+|       | 0  |   1 |
+|       | 1  |   1 |
+|       | 2  |   1 |
+|       | 3  |   1 |
+|       |    |   5 |
+| str2  | -1 |   1 |
+| str2  | 0  |   1 |
+| str2  | 1  |   1 |
+| str2  | 2  |   1 |
+| str2  | 3  |   1 |
+| str2  |    |   5 |
+| str3  | -1 |   1 |
+| str3  | 0  |   1 |
+| str3  | 1  |   1 |
+| str3  | 2  |   1 |
+| str3  | 3  |   1 |
+| str3  |    |   5 |
+| str4  | -1 |   1 |
+| str4  | 0  |   1 |
+| str4  | 1  |   1 |
+| str4  | 2  |   1 |
+| str4  | 3  |   1 |
+| str4  |    |   5 |
+|       | -1 |   1 |
+|       | -1 |   5 |
+|       | 0  |   1 |
+|       | 0  |   5 |
+|       | 1  |   1 |
+|       | 1  |   5 |
+|       | 2  |   1 |
+|       | 2  |   5 |
+|       | 3  |   1 |
+|       | 3  |   5 |
+|       |    |  25 |
+|       |    |   5 |
++-------+----+-----+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY cube(c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |  25 |
+|       |   5 |
++-------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY c
+HAVING c='1';
++---+-----+
+| c | cnt |
++---+-----+
+| 1 |   5 |
++---+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A2_B15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY c_str
+HAVING c_str='str2';
++-------+-----+
+| c_str | cnt |
++-------+-----+
+| str2  |   5 |
++-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_mv_complex_with_null_and_empty_val,
+       count(*) cnt
+FROM test_unnest
+GROUP BY c_mv_complex_with_null_and_empty_val;
++--------------------------------------+-----+
+| c_mv_complex_with_null_and_empty_val | cnt |
++--------------------------------------+-----+
+|                                      |   5 |
+| 1                                    |   5 |
+| [2]                                  |   5 |
+| [3, [4, 5]]                          |   5 |
+|                                      |   5 |
++--------------------------------------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY c;
++-------------+-----+
+| c           | cnt |
++-------------+-----+
+|             |   5 |
+| 1           |   5 |
+| [2]         |   5 |
+| [3, [4, 5]] |   5 |
+|             |   5 |
++-------------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY c_str,
+         c;
++-------+-------------+-----+
+| c_str | c           | cnt |
++-------+-------------+-----+
+|       |             |   1 |
+|       | 1           |   1 |
+|       | [2]         |   1 |
+|       | [3, [4, 5]] |   1 |
+|       |             |   1 |
+| str2  |             |   1 |
+| str2  | 1           |   1 |
+| str2  | [2]         |   1 |
+| str2  | [3, [4, 5]] |   1 |
+| str2  |             |   1 |
+| str3  |             |   1 |
+| str3  | 1           |   1 |
+| str3  | [2]         |   1 |
+| str3  | [3, [4, 5]] |   1 |
+| str3  |             |   1 |
+| str4  |             |   1 |
+| str4  | 1           |   1 |
+| str4  | [2]         |   1 |
+| str4  | [3, [4, 5]] |   1 |
+| str4  |             |   1 |
+|       |             |   1 |
+|       | 1           |   1 |
+|       | [2]         |   1 |
+|       | [3, [4, 5]] |   1 |
+|       |             |   1 |
++-------+-------------+-----+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY c_str;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY GROUPING
+SETS (c);
++-------------+-----+
+| c           | cnt |
++-------------+-----+
+|             |   5 |
+| 1           |   5 |
+| [2]         |   5 |
+| [3, [4, 5]] |   5 |
+|             |   5 |
++-------------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY GROUPING
+SETS (c_str,
+      c);
++-------+-------------+-----+
+| c_str | c           | cnt |
++-------+-------------+-----+
+|       |             |   5 |
+| str2  |             |   5 |
+| str3  |             |   5 |
+| str4  |             |   5 |
+|       |             |   5 |
+|       | 1           |   5 |
+|       | [2]         |   5 |
+|       | [3, [4, 5]] |   5 |
+|       |             |   5 |
+|       |             |   5 |
++-------+-------------+-----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY GROUPING
+SETS (c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY rollup(c);
++-------------+-----+
+| c           | cnt |
++-------------+-----+
+|             |   5 |
+| 1           |   5 |
+| [2]         |   5 |
+| [3, [4, 5]] |   5 |
+|             |  25 |
+|             |   5 |
++-------------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY rollup(c_str, c);
++-------+-------------+-----+
+| c_str | c           | cnt |
++-------+-------------+-----+
+|       |             |   1 |
+|       | 1           |   1 |
+|       | [2]         |   1 |
+|       | [3, [4, 5]] |   1 |
+|       |             |   1 |
+|       |             |   5 |
+| str2  |             |   1 |
+| str2  | 1           |   1 |
+| str2  | [2]         |   1 |
+| str2  | [3, [4, 5]] |   1 |
+| str2  |             |   1 |
+| str2  |             |   5 |
+| str3  |             |   1 |
+| str3  | 1           |   1 |
+| str3  | [2]         |   1 |
+| str3  | [3, [4, 5]] |   1 |
+| str3  |             |   1 |
+| str3  |             |   5 |
+| str4  |             |   1 |
+| str4  | 1           |   1 |
+| str4  | [2]         |   1 |
+| str4  | [3, [4, 5]] |   1 |
+| str4  |             |   1 |
+| str4  |             |   5 |
+|       |             |   1 |
+|       | 1           |   1 |
+|       | [2]         |   1 |
+|       | [3, [4, 5]] |   1 |
+|       |             |   1 |
+|       |             |  25 |
+|       |             |   5 |
++-------+-------------+-----+
+(31 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY rollup(c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |  25 |
+|       |   5 |
++-------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY cube(c);
++-------------+-----+
+| c           | cnt |
++-------------+-----+
+|             |   5 |
+| 1           |   5 |
+| [2]         |   5 |
+| [3, [4, 5]] |   5 |
+|             |  25 |
+|             |   5 |
++-------------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY cube(c_str, c);
++-------+-------------+-----+
+| c_str | c           | cnt |
++-------+-------------+-----+
+|       |             |   1 |
+|       | 1           |   1 |
+|       | [2]         |   1 |
+|       | [3, [4, 5]] |   1 |
+|       |             |   1 |
+|       |             |   5 |
+| str2  |             |   1 |
+| str2  | 1           |   1 |
+| str2  | [2]         |   1 |
+| str2  | [3, [4, 5]] |   1 |
+| str2  |             |   1 |
+| str2  |             |   5 |
+| str3  |             |   1 |
+| str3  | 1           |   1 |
+| str3  | [2]         |   1 |
+| str3  | [3, [4, 5]] |   1 |
+| str3  |             |   1 |
+| str3  |             |   5 |
+| str4  |             |   1 |
+| str4  | 1           |   1 |
+| str4  | [2]         |   1 |
+| str4  | [3, [4, 5]] |   1 |
+| str4  |             |   1 |
+| str4  |             |   5 |
+|       |             |   1 |
+|       |             |   5 |
+|       | 1           |   1 |
+|       | 1           |   5 |
+|       | [2]         |   1 |
+|       | [2]         |   5 |
+|       | [3, [4, 5]] |   1 |
+|       | [3, [4, 5]] |   5 |
+|       |             |   1 |
+|       |             |  25 |
+|       |             |   5 |
+|       |             |   5 |
++-------+-------------+-----+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY cube(c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |  25 |
+|       |   5 |
++-------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY c
+HAVING c='1';
++---+-----+
+| c | cnt |
++---+-----+
+| 1 |   5 |
++---+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A3_B15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY c_str
+HAVING c_str='str2';
++-------+-----+
+| c_str | cnt |
++-------+-----+
+| str2  |   5 |
++-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_mv_num_with_null_and_empty_val,
+       count(*) cnt
+FROM test_unnest
+GROUP BY c_mv_num_with_null_and_empty_val;
++----------------------------------+-----+
+| c_mv_num_with_null_and_empty_val | cnt |
++----------------------------------+-----+
+|                                  |   5 |
+| 1                                |   5 |
+| 2                                |   5 |
+| 3                                |   5 |
+|                                  |   5 |
++----------------------------------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY c;
++---+-----+
+| c | cnt |
++---+-----+
+|   |   5 |
+| 1 |   5 |
+| 2 |   5 |
+| 3 |   5 |
+|   |   5 |
++---+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY c_str,
+         c;
++-------+---+-----+
+| c_str | c | cnt |
++-------+---+-----+
+|       |   |   1 |
+|       | 1 |   1 |
+|       | 2 |   1 |
+|       | 3 |   1 |
+|       |   |   1 |
+| str2  |   |   1 |
+| str2  | 1 |   1 |
+| str2  | 2 |   1 |
+| str2  | 3 |   1 |
+| str2  |   |   1 |
+| str3  |   |   1 |
+| str3  | 1 |   1 |
+| str3  | 2 |   1 |
+| str3  | 3 |   1 |
+| str3  |   |   1 |
+| str4  |   |   1 |
+| str4  | 1 |   1 |
+| str4  | 2 |   1 |
+| str4  | 3 |   1 |
+| str4  |   |   1 |
+|       |   |   1 |
+|       | 1 |   1 |
+|       | 2 |   1 |
+|       | 3 |   1 |
+|       |   |   1 |
++-------+---+-----+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY c_str;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY GROUPING
+SETS (c);
++---+-----+
+| c | cnt |
++---+-----+
+|   |   5 |
+| 1 |   5 |
+| 2 |   5 |
+| 3 |   5 |
+|   |   5 |
++---+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY GROUPING
+SETS (c_str,
+      c);
++-------+---+-----+
+| c_str | c | cnt |
++-------+---+-----+
+|       |   |   5 |
+| str2  |   |   5 |
+| str3  |   |   5 |
+| str4  |   |   5 |
+|       |   |   5 |
+|       | 1 |   5 |
+|       | 2 |   5 |
+|       | 3 |   5 |
+|       |   |   5 |
+|       |   |   5 |
++-------+---+-----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY GROUPING
+SETS (c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY rollup(c);
++---+-----+
+| c | cnt |
++---+-----+
+|   |   5 |
+| 1 |   5 |
+| 2 |   5 |
+| 3 |   5 |
+|   |  25 |
+|   |   5 |
++---+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY rollup(c_str, c);
++-------+---+-----+
+| c_str | c | cnt |
++-------+---+-----+
+|       |   |   1 |
+|       | 1 |   1 |
+|       | 2 |   1 |
+|       | 3 |   1 |
+|       |   |   1 |
+|       |   |   5 |
+| str2  |   |   1 |
+| str2  | 1 |   1 |
+| str2  | 2 |   1 |
+| str2  | 3 |   1 |
+| str2  |   |   1 |
+| str2  |   |   5 |
+| str3  |   |   1 |
+| str3  | 1 |   1 |
+| str3  | 2 |   1 |
+| str3  | 3 |   1 |
+| str3  |   |   1 |
+| str3  |   |   5 |
+| str4  |   |   1 |
+| str4  | 1 |   1 |
+| str4  | 2 |   1 |
+| str4  | 3 |   1 |
+| str4  |   |   1 |
+| str4  |   |   5 |
+|       |   |   1 |
+|       | 1 |   1 |
+|       | 2 |   1 |
+|       | 3 |   1 |
+|       |   |   1 |
+|       |   |  25 |
+|       |   |   5 |
++-------+---+-----+
+(31 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY rollup(c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |  25 |
+|       |   5 |
++-------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY cube(c);
++---+-----+
+| c | cnt |
++---+-----+
+|   |   5 |
+| 1 |   5 |
+| 2 |   5 |
+| 3 |   5 |
+|   |  25 |
+|   |   5 |
++---+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY cube(c_str, c);
++-------+---+-----+
+| c_str | c | cnt |
++-------+---+-----+
+|       |   |   1 |
+|       | 1 |   1 |
+|       | 2 |   1 |
+|       | 3 |   1 |
+|       |   |   1 |
+|       |   |   5 |
+| str2  |   |   1 |
+| str2  | 1 |   1 |
+| str2  | 2 |   1 |
+| str2  | 3 |   1 |
+| str2  |   |   1 |
+| str2  |   |   5 |
+| str3  |   |   1 |
+| str3  | 1 |   1 |
+| str3  | 2 |   1 |
+| str3  | 3 |   1 |
+| str3  |   |   1 |
+| str3  |   |   5 |
+| str4  |   |   1 |
+| str4  | 1 |   1 |
+| str4  | 2 |   1 |
+| str4  | 3 |   1 |
+| str4  |   |   1 |
+| str4  |   |   5 |
+|       |   |   1 |
+|       |   |   5 |
+|       | 1 |   1 |
+|       | 1 |   5 |
+|       | 2 |   1 |
+|       | 2 |   5 |
+|       | 3 |   1 |
+|       | 3 |   5 |
+|       |   |   1 |
+|       |   |  25 |
+|       |   |   5 |
+|       |   |   5 |
++-------+---+-----+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY cube(c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |  25 |
+|       |   5 |
++-------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY c
+HAVING c='1';
++---+-----+
+| c | cnt |
++---+-----+
+| 1 |   5 |
++---+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY c_str
+HAVING c_str='str2';
++-------+-----+
+| c_str | cnt |
++-------+-----+
+| str2  |   5 |
++-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_mv_complex_with_null_and_empty_row,
+       count(*) cnt
+FROM test_unnest
+GROUP BY c_mv_complex_with_null_and_empty_row;
++--------------------------------------+-----+
+| c_mv_complex_with_null_and_empty_row | cnt |
++--------------------------------------+-----+
+|                                      |   3 |
+| 1                                    |   3 |
+| [2]                                  |   3 |
+| [3, [4, 5]]                          |   3 |
+|                                      |   5 |
++--------------------------------------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY c;
++-------------+-----+
+| c           | cnt |
++-------------+-----+
+|             |   3 |
+| 1           |   3 |
+| [2]         |   3 |
+| [3, [4, 5]] |   3 |
+|             |   5 |
++-------------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY c_str,
+         c;
++-------+-------------+-----+
+| c_str | c           | cnt |
++-------+-------------+-----+
+|       |             |   1 |
+| str2  |             |   1 |
+| str2  | 1           |   1 |
+| str2  | [2]         |   1 |
+| str2  | [3, [4, 5]] |   1 |
+| str2  |             |   1 |
+| str3  |             |   1 |
+| str3  | 1           |   1 |
+| str3  | [2]         |   1 |
+| str3  | [3, [4, 5]] |   1 |
+| str3  |             |   1 |
+| str4  |             |   1 |
+| str4  | 1           |   1 |
+| str4  | [2]         |   1 |
+| str4  | [3, [4, 5]] |   1 |
+| str4  |             |   1 |
+|       |             |   1 |
++-------+-------------+-----+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY c_str;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   1 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |   1 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY GROUPING
+SETS (c);
++-------------+-----+
+| c           | cnt |
++-------------+-----+
+|             |   3 |
+| 1           |   3 |
+| [2]         |   3 |
+| [3, [4, 5]] |   3 |
+|             |   5 |
++-------------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY GROUPING
+SETS (c_str,
+      c);
++-------+-------------+-----+
+| c_str | c           | cnt |
++-------+-------------+-----+
+|       |             |   1 |
+| str2  |             |   5 |
+| str3  |             |   5 |
+| str4  |             |   5 |
+|       |             |   3 |
+|       | 1           |   3 |
+|       | [2]         |   3 |
+|       | [3, [4, 5]] |   3 |
+|       |             |   1 |
+|       |             |   5 |
++-------+-------------+-----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY GROUPING
+SETS (c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   1 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |   1 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY rollup(c);
++-------------+-----+
+| c           | cnt |
++-------------+-----+
+|             |   3 |
+| 1           |   3 |
+| [2]         |   3 |
+| [3, [4, 5]] |   3 |
+|             |  17 |
+|             |   5 |
++-------------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY rollup(c_str, c);
++-------+-------------+-----+
+| c_str | c           | cnt |
++-------+-------------+-----+
+|       |             |   1 |
+|       |             |   1 |
+| str2  |             |   1 |
+| str2  | 1           |   1 |
+| str2  | [2]         |   1 |
+| str2  | [3, [4, 5]] |   1 |
+| str2  |             |   1 |
+| str2  |             |   5 |
+| str3  |             |   1 |
+| str3  | 1           |   1 |
+| str3  | [2]         |   1 |
+| str3  | [3, [4, 5]] |   1 |
+| str3  |             |   1 |
+| str3  |             |   5 |
+| str4  |             |   1 |
+| str4  | 1           |   1 |
+| str4  | [2]         |   1 |
+| str4  | [3, [4, 5]] |   1 |
+| str4  |             |   1 |
+| str4  |             |   5 |
+|       |             |   1 |
+|       |             |   1 |
+|       |             |  17 |
++-------+-------------+-----+
+(23 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY rollup(c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   1 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |   1 |
+|       |  17 |
++-------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY cube(c);
++-------------+-----+
+| c           | cnt |
++-------------+-----+
+|             |   3 |
+| 1           |   3 |
+| [2]         |   3 |
+| [3, [4, 5]] |   3 |
+|             |  17 |
+|             |   5 |
++-------------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY cube(c_str, c);
++-------+-------------+-----+
+| c_str | c           | cnt |
++-------+-------------+-----+
+|       |             |   1 |
+|       |             |   1 |
+| str2  |             |   1 |
+| str2  | 1           |   1 |
+| str2  | [2]         |   1 |
+| str2  | [3, [4, 5]] |   1 |
+| str2  |             |   1 |
+| str2  |             |   5 |
+| str3  |             |   1 |
+| str3  | 1           |   1 |
+| str3  | [2]         |   1 |
+| str3  | [3, [4, 5]] |   1 |
+| str3  |             |   1 |
+| str3  |             |   5 |
+| str4  |             |   1 |
+| str4  | 1           |   1 |
+| str4  | [2]         |   1 |
+| str4  | [3, [4, 5]] |   1 |
+| str4  |             |   1 |
+| str4  |             |   5 |
+|       |             |   3 |
+|       | 1           |   3 |
+|       | [2]         |   3 |
+|       | [3, [4, 5]] |   3 |
+|       |             |   1 |
+|       |             |   1 |
+|       |             |  17 |
+|       |             |   5 |
++-------+-------------+-----+
+(28 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY cube(c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   1 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |   1 |
+|       |  17 |
++-------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY c
+HAVING c='1';
++---+-----+
+| c | cnt |
++---+-----+
+| 1 |   3 |
++---+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY c_str
+HAVING c_str='str2';
++-------+-----+
+| c_str | cnt |
++-------+-----+
+| str2  |   5 |
++-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_mv_num_with_null_and_empty_row,
+       count(*) cnt
+FROM test_unnest
+GROUP BY c_mv_num_with_null_and_empty_row;
++----------------------------------+-----+
+| c_mv_num_with_null_and_empty_row | cnt |
++----------------------------------+-----+
+|                                  |   3 |
+| 1                                |   3 |
+| 2                                |   3 |
+| 3                                |   3 |
+|                                  |   5 |
++----------------------------------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY c;
++---+-----+
+| c | cnt |
++---+-----+
+|   |   3 |
+| 1 |   3 |
+| 2 |   3 |
+| 3 |   3 |
+|   |   5 |
++---+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY c_str,
+         c;
++-------+---+-----+
+| c_str | c | cnt |
++-------+---+-----+
+|       |   |   1 |
+| str2  |   |   1 |
+| str2  | 1 |   1 |
+| str2  | 2 |   1 |
+| str2  | 3 |   1 |
+| str2  |   |   1 |
+| str3  |   |   1 |
+| str3  | 1 |   1 |
+| str3  | 2 |   1 |
+| str3  | 3 |   1 |
+| str3  |   |   1 |
+| str4  |   |   1 |
+| str4  | 1 |   1 |
+| str4  | 2 |   1 |
+| str4  | 3 |   1 |
+| str4  |   |   1 |
+|       |   |   1 |
++-------+---+-----+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY c_str;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   1 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |   1 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY GROUPING
+SETS (c);
++---+-----+
+| c | cnt |
++---+-----+
+|   |   3 |
+| 1 |   3 |
+| 2 |   3 |
+| 3 |   3 |
+|   |   5 |
++---+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY GROUPING
+SETS (c_str,
+      c);
++-------+---+-----+
+| c_str | c | cnt |
++-------+---+-----+
+|       |   |   1 |
+| str2  |   |   5 |
+| str3  |   |   5 |
+| str4  |   |   5 |
+|       |   |   3 |
+|       | 1 |   3 |
+|       | 2 |   3 |
+|       | 3 |   3 |
+|       |   |   1 |
+|       |   |   5 |
++-------+---+-----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY GROUPING
+SETS (c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   1 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |   1 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY rollup(c);
++---+-----+
+| c | cnt |
++---+-----+
+|   |   3 |
+| 1 |   3 |
+| 2 |   3 |
+| 3 |   3 |
+|   |  17 |
+|   |   5 |
++---+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY rollup(c_str, c);
++-------+---+-----+
+| c_str | c | cnt |
++-------+---+-----+
+|       |   |   1 |
+|       |   |   1 |
+| str2  |   |   1 |
+| str2  | 1 |   1 |
+| str2  | 2 |   1 |
+| str2  | 3 |   1 |
+| str2  |   |   1 |
+| str2  |   |   5 |
+| str3  |   |   1 |
+| str3  | 1 |   1 |
+| str3  | 2 |   1 |
+| str3  | 3 |   1 |
+| str3  |   |   1 |
+| str3  |   |   5 |
+| str4  |   |   1 |
+| str4  | 1 |   1 |
+| str4  | 2 |   1 |
+| str4  | 3 |   1 |
+| str4  |   |   1 |
+| str4  |   |   5 |
+|       |   |   1 |
+|       |   |   1 |
+|       |   |  17 |
++-------+---+-----+
+(23 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY rollup(c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   1 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |   1 |
+|       |  17 |
++-------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY cube(c);
++---+-----+
+| c | cnt |
++---+-----+
+|   |   3 |
+| 1 |   3 |
+| 2 |   3 |
+| 3 |   3 |
+|   |  17 |
+|   |   5 |
++---+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY cube(c_str, c);
++-------+---+-----+
+| c_str | c | cnt |
++-------+---+-----+
+|       |   |   1 |
+|       |   |   1 |
+| str2  |   |   1 |
+| str2  | 1 |   1 |
+| str2  | 2 |   1 |
+| str2  | 3 |   1 |
+| str2  |   |   1 |
+| str2  |   |   5 |
+| str3  |   |   1 |
+| str3  | 1 |   1 |
+| str3  | 2 |   1 |
+| str3  | 3 |   1 |
+| str3  |   |   1 |
+| str3  |   |   5 |
+| str4  |   |   1 |
+| str4  | 1 |   1 |
+| str4  | 2 |   1 |
+| str4  | 3 |   1 |
+| str4  |   |   1 |
+| str4  |   |   5 |
+|       |   |   3 |
+|       | 1 |   3 |
+|       | 2 |   3 |
+|       | 3 |   3 |
+|       |   |   1 |
+|       |   |   1 |
+|       |   |  17 |
+|       |   |   5 |
++-------+---+-----+
+(28 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY cube(c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   1 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |   1 |
+|       |  17 |
++-------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY c
+HAVING c='1';
++---+-----+
+| c | cnt |
++---+-----+
+| 1 |   3 |
++---+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY c_str
+HAVING c_str='str2';
++-------+-----+
+| c_str | cnt |
++-------+-----+
+| str2  |   5 |
++-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_mv_all_null_and_empty_val,
+       count(*) cnt
+FROM test_unnest
+GROUP BY c_mv_all_null_and_empty_val;
++-----------------------------+-----+
+| c_mv_all_null_and_empty_val | cnt |
++-----------------------------+-----+
+|                             |  10 |
+|                             |  15 |
++-----------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY c;
++---+-----+
+| c | cnt |
++---+-----+
+|   |  10 |
+|   |  15 |
++---+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY c_str,
+         c;
++-------+---+-----+
+| c_str | c | cnt |
++-------+---+-----+
+|       |   |   2 |
+|       |   |   3 |
+| str2  |   |   2 |
+| str2  |   |   3 |
+| str3  |   |   2 |
+| str3  |   |   3 |
+| str4  |   |   2 |
+| str4  |   |   3 |
+|       |   |   2 |
+|       |   |   3 |
++-------+---+-----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY c_str;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY GROUPING
+SETS (c);
++---+-----+
+| c | cnt |
++---+-----+
+|   |  10 |
+|   |  15 |
++---+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY GROUPING
+SETS (c_str,
+      c);
++-------+---+-----+
+| c_str | c | cnt |
++-------+---+-----+
+|       |   |   5 |
+| str2  |   |   5 |
+| str3  |   |   5 |
+| str4  |   |   5 |
+|       |   |  10 |
+|       |   |  15 |
+|       |   |   5 |
++-------+---+-----+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY GROUPING
+SETS (c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY rollup(c);
++---+-----+
+| c | cnt |
++---+-----+
+|   |  10 |
+|   |  15 |
+|   |  25 |
++---+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY rollup(c_str, c);
++-------+---+-----+
+| c_str | c | cnt |
++-------+---+-----+
+|       |   |   2 |
+|       |   |   3 |
+|       |   |   5 |
+| str2  |   |   2 |
+| str2  |   |   3 |
+| str2  |   |   5 |
+| str3  |   |   2 |
+| str3  |   |   3 |
+| str3  |   |   5 |
+| str4  |   |   2 |
+| str4  |   |   3 |
+| str4  |   |   5 |
+|       |   |   2 |
+|       |   |  25 |
+|       |   |   3 |
+|       |   |   5 |
++-------+---+-----+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY rollup(c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |  25 |
+|       |   5 |
++-------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY cube(c);
++---+-----+
+| c | cnt |
++---+-----+
+|   |  10 |
+|   |  15 |
+|   |  25 |
++---+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY cube(c_str, c);
++-------+---+-----+
+| c_str | c | cnt |
++-------+---+-----+
+|       |   |   2 |
+|       |   |   3 |
+|       |   |   5 |
+| str2  |   |   2 |
+| str2  |   |   3 |
+| str2  |   |   5 |
+| str3  |   |   2 |
+| str3  |   |   3 |
+| str3  |   |   5 |
+| str4  |   |   2 |
+| str4  |   |   3 |
+| str4  |   |   5 |
+|       |   |  10 |
+|       |   |   2 |
+|       |   |  15 |
+|       |   |  25 |
+|       |   |   3 |
+|       |   |   5 |
++-------+---+-----+
+(18 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY cube(c_str);
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
+|       |  25 |
+|       |   5 |
++-------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY c
+HAVING c='1';
++---+-----+
+| c | cnt |
++---+-----+
++---+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY c_str
+HAVING c_str='str2';
++-------+-----+
+| c_str | cnt |
++-------+-----+
+| str2  |   5 |
++-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY c
+ORDER BY c ASC;
++-------------+-----+
+| c           | cnt |
++-------------+-----+
+| 1           |   5 |
+| [2]         |   5 |
+| [3, [4, 5]] |   5 |
+| my_empty    |   5 |
+| my_null     |   5 |
++-------------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY c
+ORDER BY 1 DESC;
++-------------+-----+
+| c           | cnt |
++-------------+-----+
+| my_null     |   5 |
+| my_empty    |   5 |
+| [3, [4, 5]] |   5 |
+| [2]         |   5 |
+| 1           |   5 |
++-------------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+ORDER BY c ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   ORDER BY c ASC);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   ORDER BY 1 DESC);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY __time
+ORDER BY __time ASC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |  25 |
++-------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY __time
+ORDER BY __time DESC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |  25 |
++-------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+ORDER BY __time ASC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+ORDER BY 1 DESC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   ORDER BY __time ASC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   ORDER BY 1 DESC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY c_str
+ORDER BY c_str ASC;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+GROUP BY c_str
+ORDER BY 1 DESC;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+| str4  |   5 |
+| str3  |   5 |
+| str2  |   5 |
+|       |   5 |
+|       |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+ORDER BY c_str ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM
+  (SELECT c_str
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   ORDER BY c_str ASC);
++-------+
+| c_str |
++-------+
+|       |
+|       |
+|       |
+|       |
+|       |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+|       |
+|       |
+|       |
+|       |
+|       |
++-------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM
+  (SELECT c_str
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| c_str |
++-------+
+|       |
+|       |
+|       |
+|       |
+|       |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+|       |
+|       |
+|       |
+|       |
+|       |
++-------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY c
+ORDER BY c ASC;
++----+-----+
+| c  | cnt |
++----+-----+
+| -1 |   5 |
+| 0  |   5 |
+| 1  |   5 |
+| 2  |   5 |
+| 3  |   5 |
++----+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY c
+ORDER BY 1 DESC;
++----+-----+
+| c  | cnt |
++----+-----+
+| 3  |   5 |
+| 2  |   5 |
+| 1  |   5 |
+| 0  |   5 |
+| -1 |   5 |
++----+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+ORDER BY c ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   ORDER BY c ASC);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   ORDER BY 1 DESC);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY __time
+ORDER BY __time ASC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |  25 |
++-------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY __time
+ORDER BY __time DESC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |  25 |
++-------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+ORDER BY __time ASC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+ORDER BY 1 DESC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   ORDER BY __time ASC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   ORDER BY 1 DESC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY c_str
+ORDER BY c_str ASC;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+GROUP BY c_str
+ORDER BY 1 DESC;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+| str4  |   5 |
+| str3  |   5 |
+| str2  |   5 |
+|       |   5 |
+|       |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+ORDER BY c_str ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM
+  (SELECT c_str
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   ORDER BY c_str ASC);
++-------+
+| c_str |
++-------+
+|       |
+|       |
+|       |
+|       |
+|       |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+|       |
+|       |
+|       |
+|       |
+|       |
++-------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM
+  (SELECT c_str
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| c_str |
++-------+
+|       |
+|       |
+|       |
+|       |
+|       |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+|       |
+|       |
+|       |
+|       |
+|       |
++-------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY c
+ORDER BY c ASC;
++-------------+-----+
+| c           | cnt |
++-------------+-----+
+|             |   5 |
+|             |   5 |
+| 1           |   5 |
+| [2]         |   5 |
+| [3, [4, 5]] |   5 |
++-------------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY c
+ORDER BY 1 DESC;
++-------------+-----+
+| c           | cnt |
++-------------+-----+
+| [3, [4, 5]] |   5 |
+| [2]         |   5 |
+| 1           |   5 |
+|             |   5 |
+|             |   5 |
++-------------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+ORDER BY c ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   ORDER BY c ASC);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   ORDER BY 1 DESC);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY __time
+ORDER BY __time ASC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |  25 |
++-------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY __time
+ORDER BY __time DESC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |  25 |
++-------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+ORDER BY __time ASC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+ORDER BY 1 DESC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   ORDER BY __time ASC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   ORDER BY 1 DESC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY c_str
+ORDER BY c_str ASC;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+GROUP BY c_str
+ORDER BY 1 DESC;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+| str4  |   5 |
+| str3  |   5 |
+| str2  |   5 |
+|       |   5 |
+|       |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+ORDER BY c_str ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM
+  (SELECT c_str
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   ORDER BY c_str ASC);
++-------+
+| c_str |
++-------+
+|       |
+|       |
+|       |
+|       |
+|       |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+|       |
+|       |
+|       |
+|       |
+|       |
++-------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A3_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM
+  (SELECT c_str
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| c_str |
++-------+
+|       |
+|       |
+|       |
+|       |
+|       |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+|       |
+|       |
+|       |
+|       |
+|       |
++-------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY c
+ORDER BY c ASC;
++---+-----+
+| c | cnt |
++---+-----+
+|   |   5 |
+|   |   5 |
+| 1 |   5 |
+| 2 |   5 |
+| 3 |   5 |
++---+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY c
+ORDER BY 1 DESC;
++---+-----+
+| c | cnt |
++---+-----+
+| 3 |   5 |
+| 2 |   5 |
+| 1 |   5 |
+|   |   5 |
+|   |   5 |
++---+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+ORDER BY c ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   ORDER BY c ASC);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   ORDER BY 1 DESC);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY __time
+ORDER BY __time ASC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |  25 |
++-------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY __time
+ORDER BY __time DESC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |  25 |
++-------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+ORDER BY __time ASC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+ORDER BY 1 DESC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   ORDER BY __time ASC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   ORDER BY 1 DESC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY c_str
+ORDER BY c_str ASC;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+GROUP BY c_str
+ORDER BY 1 DESC;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+| str4  |   5 |
+| str3  |   5 |
+| str2  |   5 |
+|       |   5 |
+|       |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+ORDER BY c_str ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM
+  (SELECT c_str
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   ORDER BY c_str ASC);
++-------+
+| c_str |
++-------+
+|       |
+|       |
+|       |
+|       |
+|       |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+|       |
+|       |
+|       |
+|       |
+|       |
++-------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A4_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM
+  (SELECT c_str
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| c_str |
++-------+
+|       |
+|       |
+|       |
+|       |
+|       |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+|       |
+|       |
+|       |
+|       |
+|       |
++-------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY c
+ORDER BY c ASC;
++-------------+-----+
+| c           | cnt |
++-------------+-----+
+|             |   5 |
+|             |   3 |
+| 1           |   3 |
+| [2]         |   3 |
+| [3, [4, 5]] |   3 |
++-------------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY c
+ORDER BY 1 DESC;
++-------------+-----+
+| c           | cnt |
++-------------+-----+
+| [3, [4, 5]] |   3 |
+| [2]         |   3 |
+| 1           |   3 |
+|             |   3 |
+|             |   5 |
++-------------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+ORDER BY c ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   ORDER BY c ASC);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   ORDER BY 1 DESC);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY __time
+ORDER BY __time ASC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |  17 |
++-------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY __time
+ORDER BY __time DESC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |  17 |
++-------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+ORDER BY __time ASC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+ORDER BY 1 DESC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   ORDER BY __time ASC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   ORDER BY 1 DESC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY c_str
+ORDER BY c_str ASC;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   1 |
+|       |   1 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+GROUP BY c_str
+ORDER BY 1 DESC;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+| str4  |   5 |
+| str3  |   5 |
+| str2  |   5 |
+|       |   1 |
+|       |   1 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+ORDER BY c_str ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM
+  (SELECT c_str
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   ORDER BY c_str ASC);
++-------+
+| c_str |
++-------+
+|       |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+|       |
++-------+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM
+  (SELECT c_str
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| c_str |
++-------+
+|       |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+|       |
++-------+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY c
+ORDER BY c ASC;
++---+-----+
+| c | cnt |
++---+-----+
+|   |   5 |
+|   |   3 |
+| 1 |   3 |
+| 2 |   3 |
+| 3 |   3 |
++---+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY c
+ORDER BY 1 DESC;
++---+-----+
+| c | cnt |
++---+-----+
+| 3 |   3 |
+| 2 |   3 |
+| 1 |   3 |
+|   |   3 |
+|   |   5 |
++---+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+ORDER BY c ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   ORDER BY c ASC);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   ORDER BY 1 DESC);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY __time
+ORDER BY __time ASC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |  17 |
++-------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY __time
+ORDER BY __time DESC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |  17 |
++-------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+ORDER BY __time ASC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+ORDER BY 1 DESC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   ORDER BY __time ASC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   ORDER BY 1 DESC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY c_str
+ORDER BY c_str ASC;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   1 |
+|       |   1 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+GROUP BY c_str
+ORDER BY 1 DESC;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+| str4  |   5 |
+| str3  |   5 |
+| str2  |   5 |
+|       |   1 |
+|       |   1 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+ORDER BY c_str ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM
+  (SELECT c_str
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   ORDER BY c_str ASC);
++-------+
+| c_str |
++-------+
+|       |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+|       |
++-------+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM
+  (SELECT c_str
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| c_str |
++-------+
+|       |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+|       |
++-------+
+(17 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY c
+ORDER BY c ASC;
++---+-----+
+| c | cnt |
++---+-----+
+|   |  15 |
+|   |  10 |
++---+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY c
+ORDER BY 1 DESC;
++---+-----+
+| c | cnt |
++---+-----+
+|   |  10 |
+|   |  15 |
++---+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+ORDER BY c ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   ORDER BY c ASC);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT c
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   ORDER BY 1 DESC);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY __time
+ORDER BY __time ASC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |  25 |
++-------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY __time
+ORDER BY __time DESC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |  25 |
++-------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+ORDER BY __time ASC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+ORDER BY 1 DESC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   ORDER BY __time ASC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   ORDER BY 1 DESC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY c_str
+ORDER BY c_str ASC;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+|       |   5 |
+|       |   5 |
+| str2  |   5 |
+| str3  |   5 |
+| str4  |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str,
+       count(*) cnt
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+GROUP BY c_str
+ORDER BY 1 DESC;
++-------+-----+
+| c_str | cnt |
++-------+-----+
+| str4  |   5 |
+| str3  |   5 |
+| str2  |   5 |
+|       |   5 |
+|       |   5 |
++-------+-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+ORDER BY c_str ASC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+ORDER BY 1 DESC;
+CannotBuildQueryException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM
+  (SELECT c_str
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   ORDER BY c_str ASC);
++-------+
+| c_str |
++-------+
+|       |
+|       |
+|       |
+|       |
+|       |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+|       |
+|       |
+|       |
+|       |
+|       |
++-------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_str
+FROM
+  (SELECT c_str
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   ORDER BY 1 DESC);
++-------+
+| c_str |
++-------+
+|       |
+|       |
+|       |
+|       |
+|       |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str2  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str3  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+| str4  |
+|       |
+|       |
+|       |
+|       |
+|       |
++-------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A1_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   LIMIT 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A1_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|  24 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A1_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   LIMIT 1
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A2_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   LIMIT 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A2_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|  24 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A2_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   LIMIT 1
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A3_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   LIMIT 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A3_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|  24 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A3_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   LIMIT 1
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A4_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   LIMIT 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A4_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|  24 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A4_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   LIMIT 1
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A5_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   LIMIT 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A5_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|  16 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A5_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   LIMIT 1
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A6_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   LIMIT 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A6_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|  16 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A6_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   LIMIT 1
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A7_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   LIMIT 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A7_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|  24 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A7_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   LIMIT 1
+   OFFSET 1);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+INNER JOIN test_unnest t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+INNER JOIN test_unnest t2 ON u.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+INNER JOIN test_unnest t2,
+           unnest(mv_to_array(t2.c_mv_num_with_null_and_empty_val)) AS u(c) ON cast(t2.c_long AS char)=u.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+INNER JOIN test_unnest t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+INNER JOIN test_unnest t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t2.c_long=t1.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t2.c=cast(t1.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM t1
+INNER JOIN test_unnest t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM t1
+INNER JOIN test_unnest t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+INNER JOIN t2 ON t2.c_long=t1.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+INNER JOIN t2 ON t2.c=cast(t1.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B12 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+INNER JOIN test_unnest t2,
+           unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B13 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+INNER JOIN test_unnest t2,
+           unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B14 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+INNER JOIN test_unnest t2,
+           unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON cast(t1.c_long AS char)=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+INNER JOIN test_unnest t2,
+           unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+INNER JOIN test_unnest,
+           unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B17 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+INNER JOIN test_unnest,
+           unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B18 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+INNER JOIN test_unnest,
+           unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON cast(t1.c_long AS char)=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B19 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+INNER JOIN test_unnest,
+           unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(75 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
++-------+--------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(75 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+INNER JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
++-------+--------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+INNER JOIN t1 t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(75 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+INNER JOIN t1 t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+INNER JOIN t1 t2 ON t1.c_long=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+INNER JOIN t1 t2 ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
++-------+--------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+JOIN test_unnest t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+JOIN test_unnest t2 ON u.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+JOIN test_unnest t2,
+     unnest(mv_to_array(t2.c_mv_num_with_null_and_empty_val)) AS u(c) ON cast(t2.c_long AS char)=u.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+JOIN test_unnest t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+JOIN test_unnest t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t2.c_long=t1.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t2.c=cast(t1.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM t1
+JOIN test_unnest t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM t1
+JOIN test_unnest t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+JOIN t2 ON t2.c_long=t1.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+JOIN t2 ON t2.c=cast(t1.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B12 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+JOIN test_unnest t2,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B13 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+JOIN test_unnest t2,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B14 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+JOIN test_unnest t2,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON cast(t1.c_long AS char)=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+JOIN test_unnest t2,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+JOIN test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B17 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+JOIN test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B18 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+JOIN test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON cast(t1.c_long AS char)=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B19 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+JOIN test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(75 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
++-------+--------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(75 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
++-------+--------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+JOIN t1 t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(75 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+JOIN t1 t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+JOIN t1 t2 ON t1.c_long=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+JOIN t1 t2 ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
++-------+--------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+LEFT JOIN test_unnest t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+LEFT JOIN test_unnest t2 ON u.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+LEFT JOIN test_unnest t2,
+          unnest(mv_to_array(t2.c_mv_num_with_null_and_empty_val)) AS u(c) ON cast(t2.c_long AS char)=u.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+LEFT JOIN test_unnest t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+LEFT JOIN test_unnest t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t2.c_long=t1.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t2.c=cast(t1.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM t1
+LEFT JOIN test_unnest t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM t1
+LEFT JOIN test_unnest t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+LEFT JOIN t2 ON t2.c_long=t1.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+LEFT JOIN t2 ON t2.c=cast(t1.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B12 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+LEFT JOIN test_unnest t2,
+          unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B13 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+LEFT JOIN test_unnest t2,
+          unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B14 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+LEFT JOIN test_unnest t2,
+          unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON cast(t1.c_long AS char)=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+LEFT JOIN test_unnest t2,
+          unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+LEFT JOIN test_unnest,
+          unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B17 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+LEFT JOIN test_unnest,
+          unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B18 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+LEFT JOIN test_unnest,
+          unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON cast(t1.c_long AS char)=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B19 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+LEFT JOIN test_unnest,
+          unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(75 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
++-------+--------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(75 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+LEFT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
++-------+--------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+LEFT JOIN t1 t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(75 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+LEFT JOIN t1 t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+LEFT JOIN t1 t2 ON t1.c_long=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+LEFT JOIN t1 t2 ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
++-------+--------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+RIGHT JOIN test_unnest t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+RIGHT JOIN test_unnest t2 ON u.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+RIGHT JOIN test_unnest t2,
+           unnest(mv_to_array(t2.c_mv_num_with_null_and_empty_val)) AS u(c) ON cast(t2.c_long AS char)=u.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+RIGHT JOIN test_unnest t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+RIGHT JOIN test_unnest t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t2.c_long=t1.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t2.c=cast(t1.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM t1
+RIGHT JOIN test_unnest t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM t1
+RIGHT JOIN test_unnest t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+RIGHT JOIN t2 ON t2.c_long=t1.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+RIGHT JOIN t2 ON t2.c=cast(t1.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B12 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+RIGHT JOIN test_unnest t2,
+           unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B13 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+RIGHT JOIN test_unnest t2,
+           unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B14 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+RIGHT JOIN test_unnest t2,
+           unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON cast(t1.c_long AS char)=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+RIGHT JOIN test_unnest t2,
+           unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+RIGHT JOIN test_unnest,
+           unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B17 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+RIGHT JOIN test_unnest,
+           unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B18 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+RIGHT JOIN test_unnest,
+           unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON cast(t1.c_long AS char)=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B19 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+RIGHT JOIN test_unnest,
+           unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(75 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
++-------+--------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(75 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+RIGHT JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
++-------+--------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+RIGHT JOIN t1 t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(75 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+RIGHT JOIN t1 t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+RIGHT JOIN t1 t2 ON t1.c_long=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+RIGHT JOIN t1 t2 ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
++-------+--------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+FULL JOIN test_unnest t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+FULL JOIN test_unnest t2 ON u.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+FULL JOIN test_unnest t2,
+          unnest(mv_to_array(t2.c_mv_num_with_null_and_empty_val)) AS u(c) ON cast(t2.c_long AS char)=u.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+FULL JOIN test_unnest t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+FULL JOIN test_unnest t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t2.c_long=t1.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t2.c=cast(t1.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM t1
+FULL JOIN test_unnest t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM t1
+FULL JOIN test_unnest t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+FULL JOIN t2 ON t2.c_long=t1.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+FULL JOIN t2 ON t2.c=cast(t1.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B12 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+FULL JOIN test_unnest t2,
+          unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B13 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+FULL JOIN test_unnest t2,
+          unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B14 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+FULL JOIN test_unnest t2,
+          unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON cast(t1.c_long AS char)=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B15 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+FULL JOIN test_unnest t2,
+          unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c) ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+FULL JOIN test_unnest,
+          unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B17 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+FULL JOIN test_unnest,
+          unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B18 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+FULL JOIN test_unnest,
+          unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON cast(t1.c_long AS char)=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B19 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+FULL JOIN test_unnest,
+          unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) t2 AS u(c) ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(75 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
++-------+--------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(75 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c_long=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+FULL JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2 ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
++-------+--------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+FULL JOIN t1 t2 ON t1.c_long=t2.c_long
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(75 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+FULL JOIN t1 t2 ON t1.c=cast(t2.c_long AS char)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+FULL JOIN t1 t2 ON t1.c_long=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+FULL JOIN t1 t2 ON t1.c=t2.c
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
++-------+--------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+CROSS JOIN unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+CROSS JOIN test_unnest t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(45 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+CROSS JOIN test_unnest t2,
+           unnest(mv_to_array(t2.c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(45 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+CROSS JOIN test_unnest t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(45 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(45 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM t1
+CROSS JOIN test_unnest t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(45 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1
+CROSS JOIN t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(45 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c1
+FROM test_unnest t1
+CROSS JOIN unnest(mv_to_array(t1.c_mv_num_with_null_and_empty_val)) AS u1(c1)
+CROSS JOIN test_unnest t2
+CROSS JOIN unnest(mv_to_array(t2.c_mv_num_with_null_and_empty_val)) AS u2(c2)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+----+
+| c_str | c_long | c1 |
++-------+--------+----+
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 | 1  |
+|       |      1 | 1  |
+|       |      1 | 1  |
+|       |      1 | 1  |
+|       |      1 | 1  |
+|       |      1 | 1  |
+|       |      1 | 1  |
+|       |      1 | 1  |
+|       |      1 | 1  |
+|       |      1 | 1  |
+|       |      1 | 1  |
+|       |      1 | 1  |
+|       |      1 | 1  |
+|       |      1 | 1  |
+|       |      1 | 1  |
+|       |      1 | 2  |
+|       |      1 | 2  |
+|       |      1 | 2  |
+|       |      1 | 2  |
+|       |      1 | 2  |
+|       |      1 | 2  |
+|       |      1 | 2  |
+|       |      1 | 2  |
+|       |      1 | 2  |
+|       |      1 | 2  |
+|       |      1 | 2  |
+|       |      1 | 2  |
+|       |      1 | 2  |
+|       |      1 | 2  |
+|       |      1 | 2  |
+|       |      1 | 3  |
+|       |      1 | 3  |
+|       |      1 | 3  |
+|       |      1 | 3  |
+|       |      1 | 3  |
+|       |      1 | 3  |
+|       |      1 | 3  |
+|       |      1 | 3  |
+|       |      1 | 3  |
+|       |      1 | 3  |
+|       |      1 | 3  |
+|       |      1 | 3  |
+|       |      1 | 3  |
+|       |      1 | 3  |
+|       |      1 | 3  |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+|       |      1 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 | 1  |
+| str2  |      2 | 1  |
+| str2  |      2 | 1  |
+| str2  |      2 | 1  |
+| str2  |      2 | 1  |
+| str2  |      2 | 1  |
+| str2  |      2 | 1  |
+| str2  |      2 | 1  |
+| str2  |      2 | 1  |
+| str2  |      2 | 1  |
+| str2  |      2 | 1  |
+| str2  |      2 | 1  |
+| str2  |      2 | 1  |
+| str2  |      2 | 1  |
+| str2  |      2 | 1  |
+| str2  |      2 | 2  |
+| str2  |      2 | 2  |
+| str2  |      2 | 2  |
+| str2  |      2 | 2  |
+| str2  |      2 | 2  |
+| str2  |      2 | 2  |
+| str2  |      2 | 2  |
+| str2  |      2 | 2  |
+| str2  |      2 | 2  |
+| str2  |      2 | 2  |
+| str2  |      2 | 2  |
+| str2  |      2 | 2  |
+| str2  |      2 | 2  |
+| str2  |      2 | 2  |
+| str2  |      2 | 2  |
+| str2  |      2 | 3  |
+| str2  |      2 | 3  |
+| str2  |      2 | 3  |
+| str2  |      2 | 3  |
+| str2  |      2 | 3  |
+| str2  |      2 | 3  |
+| str2  |      2 | 3  |
+| str2  |      2 | 3  |
+| str2  |      2 | 3  |
+| str2  |      2 | 3  |
+| str2  |      2 | 3  |
+| str2  |      2 | 3  |
+| str2  |      2 | 3  |
+| str2  |      2 | 3  |
+| str2  |      2 | 3  |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+| str2  |      2 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 | 1  |
+|       |      0 | 1  |
+|       |      0 | 1  |
+|       |      0 | 1  |
+|       |      0 | 1  |
+|       |      0 | 1  |
+|       |      0 | 1  |
+|       |      0 | 1  |
+|       |      0 | 1  |
+|       |      0 | 1  |
+|       |      0 | 1  |
+|       |      0 | 1  |
+|       |      0 | 1  |
+|       |      0 | 1  |
+|       |      0 | 1  |
+|       |      0 | 2  |
+|       |      0 | 2  |
+|       |      0 | 2  |
+|       |      0 | 2  |
+|       |      0 | 2  |
+|       |      0 | 2  |
+|       |      0 | 2  |
+|       |      0 | 2  |
+|       |      0 | 2  |
+|       |      0 | 2  |
+|       |      0 | 2  |
+|       |      0 | 2  |
+|       |      0 | 2  |
+|       |      0 | 2  |
+|       |      0 | 2  |
+|       |      0 | 3  |
+|       |      0 | 3  |
+|       |      0 | 3  |
+|       |      0 | 3  |
+|       |      0 | 3  |
+|       |      0 | 3  |
+|       |      0 | 3  |
+|       |      0 | 3  |
+|       |      0 | 3  |
+|       |      0 | 3  |
+|       |      0 | 3  |
+|       |      0 | 3  |
+|       |      0 | 3  |
+|       |      0 | 3  |
+|       |      0 | 3  |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
+|       |      0 |    |
++-------+--------+----+
+(225 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(225 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+CROSS JOIN
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(225 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1
+CROSS JOIN t1 t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(225 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t2.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c),
+     test_unnest t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t1.c_long=t2.c_long;
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c),
+     test_unnest t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND u.c=cast(t2.c_long AS char);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1,
+     test_unnest t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t1.c_long=t2.c_long;
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1,
+     test_unnest t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t1.c=cast(t2.c_long AS char);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long=t1.c_long;
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c=cast(t1.c_long AS char);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM t1,
+     test_unnest t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t1.c_long=t2.c_long;
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM t1,
+     test_unnest t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t1.c=cast(t2.c_long AS char);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long=t1.c_long;
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 |   |
++-------+--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t2 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       c
+FROM test_unnest t1,
+     t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c=cast(t1.c_long AS char);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
++-------+--------+---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B16 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c1
+FROM test_unnest t1,
+     unnest(mv_to_array(t1.c_mv_num_with_null_and_empty_val)) AS u1(c1),
+     test_unnest,
+     unnest(mv_to_array(t2.c_mv_num_with_null_and_empty_val)) t2 AS u2(c2)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t1.c_long=t2.c_long;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B17 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c1
+FROM test_unnest t1,
+     unnest(mv_to_array(t1.c_mv_num_with_null_and_empty_val)) AS u1(c1),
+     test_unnest,
+     unnest(mv_to_array(t2.c_mv_num_with_null_and_empty_val)) t2 AS u2(c2)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t1.c1=cast(t2.c_long AS char);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B18 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c1
+FROM test_unnest t1,
+     unnest(mv_to_array(t1.c_mv_num_with_null_and_empty_val)) AS u1(c1),
+     test_unnest,
+     unnest(mv_to_array(t2.c_mv_num_with_null_and_empty_val)) t2 AS u2(c2)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND cast(t1.c_long AS char)=t2.c2;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B19 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       c1
+FROM test_unnest t1,
+     unnest(mv_to_array(t1.c_mv_num_with_null_and_empty_val)) AS u1(c1),
+     test_unnest,
+     unnest(mv_to_array(t2.c_mv_num_with_null_and_empty_val)) t2 AS u2(c2)
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t1.c1=t2.c2;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1,
+
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t1.c_long=t2.c_long;
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(75 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1,
+
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t1.c=cast(t2.c_long AS char);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1,
+
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND cast(t1.c_long AS char)=t2.c;
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t1,
+
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t1.c=t2.c;
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
++-------+--------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1,
+
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t1.c_long=t2.c_long;
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(75 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1,
+
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t1.c=cast(t2.c_long AS char);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1,
+
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND cast(t1.c_long AS char)=t2.c;
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1,
+
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)) t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t1.c=t2.c;
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
++-------+--------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1,
+     t1 t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t1.c_long=t2.c_long;
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
++-------+--------+---+
+(75 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1,
+     t1 t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t1.c=cast(t2.c_long AS char);
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1,
+     t1 t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND cast(t1.c_long AS char)=t2.c;
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
++-------+--------+---+
+(30 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+SELECT t1.c_str,
+       t1.c_long,
+       t1.c
+FROM t1,
+     t1 t2
+WHERE t1.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t2.c_long IN (0,
+                    1,
+                    2,
+                    999)
+  AND t1.c=t2.c;
++-------+--------+---+
+| c_str | c_long | c |
++-------+--------+---+
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 |   |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 1 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 2 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+|       |      1 | 3 |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 |   |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 1 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 2 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+| str2  |      2 | 3 |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 |   |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 1 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 2 |
+|       |      0 | 3 |
+|       |      0 | 3 |
+|       |      0 | 3 |
++-------+--------+---+
+(36 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    999)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_long IN (2,
+                    999));
++--------+-------------+
+| c_long | c           |
++--------+-------------+
+|      0 | 1           |
+|      0 | [2]         |
+|      0 | [3, [4, 5]] |
+|      0 | my_empty    |
+|      0 | my_null     |
+|      1 | 1           |
+|      1 | [2]         |
+|      1 | [3, [4, 5]] |
+|      1 | my_empty    |
+|      1 | my_null     |
+|      2 | 1           |
+|      2 | [2]         |
+|      2 | [3, [4, 5]] |
+|      2 | my_empty    |
+|      2 | my_null     |
++--------+-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A1_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A2_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    999)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_long IN (2,
+                    999));
++--------+----+
+| c_long | c  |
++--------+----+
+|      0 | -1 |
+|      0 | 0  |
+|      0 | 1  |
+|      0 | 2  |
+|      0 | 3  |
+|      1 | -1 |
+|      1 | 0  |
+|      1 | 1  |
+|      1 | 2  |
+|      1 | 3  |
+|      2 | -1 |
+|      2 | 0  |
+|      2 | 1  |
+|      2 | 2  |
+|      2 | 3  |
++--------+----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A2_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A3_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    999)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (2,
+                    999));
++--------+-------------+
+| c_long | c           |
++--------+-------------+
+|      0 |             |
+|      0 | 1           |
+|      0 | [2]         |
+|      0 | [3, [4, 5]] |
+|      0 |             |
+|      1 |             |
+|      1 | 1           |
+|      1 | [2]         |
+|      1 | [3, [4, 5]] |
+|      1 |             |
+|      2 |             |
+|      2 | 1           |
+|      2 | [2]         |
+|      2 | [3, [4, 5]] |
+|      2 |             |
++--------+-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A3_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    999)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (2,
+                    999));
++--------+---+
+| c_long | c |
++--------+---+
+|      0 |   |
+|      0 | 1 |
+|      0 | 2 |
+|      0 | 3 |
+|      0 |   |
+|      1 |   |
+|      1 | 1 |
+|      1 | 2 |
+|      1 | 3 |
+|      1 |   |
+|      2 |   |
+|      2 | 1 |
+|      2 | 2 |
+|      2 | 3 |
+|      2 |   |
++--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A4_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    999)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_long IN (2,
+                    999));
++--------+-------------+
+| c_long | c           |
++--------+-------------+
+|      0 |             |
+|      1 |             |
+|      2 |             |
+|      2 | 1           |
+|      2 | [2]         |
+|      2 | [3, [4, 5]] |
+|      2 |             |
++--------+-------------+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A5_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    999)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_long IN (2,
+                    999));
++--------+---+
+| c_long | c |
++--------+---+
+|      0 |   |
+|      1 |   |
+|      2 |   |
+|      2 | 1 |
+|      2 | 2 |
+|      2 | 3 |
+|      2 |   |
++--------+---+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A6_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long,
+       c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    999)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (2,
+                    999));
++--------+---+
+| c_long | c |
++--------+---+
+|      0 |   |
+|      0 |   |
+|      0 |   |
+|      0 |   |
+|      0 |   |
+|      1 |   |
+|      1 |   |
+|      1 |   |
+|      1 |   |
+|      1 |   |
+|      2 |   |
+|      2 |   |
+|      2 |   |
+|      2 |   |
+|      2 |   |
++--------+---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A7_B2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   UNION ALL SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# Total query count 579 Positive tests: 455 Negative tests: 124
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql_filter.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql_filter.iq
new file mode 100644
index 000000000000..2c0abdc71da9
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql_filter.iq
@@ -0,0 +1,46780 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaUnnest/mv&numMergeBuffers=3
+!set outputformat mysql
+SELECT *
+FROM test_unnest;
++-------------------------+-------+--------+---------+----------+------------------------------------------------+------------------------+--------------------------------------+----------------------------------+--------------------------------------+----------------------------------+-----------------------------+
+| __time                  | c_str | c_long | c_float | c_double | c_mv_complex                                   | c_mv_num               | c_mv_complex_with_null_and_empty_val | c_mv_num_with_null_and_empty_val | c_mv_complex_with_null_and_empty_row | c_mv_num_with_null_and_empty_row | c_mv_all_null_and_empty_val |
++-------------------------+-------+--------+---------+----------+------------------------------------------------+------------------------+--------------------------------------+----------------------------------+--------------------------------------+----------------------------------+-----------------------------+
+| 2022-01-01 00:00:00.000 |       |      1 |     0.1 |      0.1 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 | str2  |      2 |     0.2 |      0.2 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 | str3  |      3 |     0.3 |      0.3 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 | str4  |      4 |     0.4 |      0.4 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 |       |      0 |     0.0 |      0.0 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      |
++-------------------------+-------+--------+---------+----------+------------------------------------------------+------------------------+--------------------------------------+----------------------------------+--------------------------------------+----------------------------------+-----------------------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c='1');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c='1'), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c<>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c<>'1');
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<>'1'), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c<>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c<>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c>'1');
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>'1'), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c>='1';
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c>='1');
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>='1'), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c>='1';
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c>='1';
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c<'1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c<'1');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<'1'), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c<'1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c<'1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c<='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c<='1');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<='1'), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c<='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c<='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999));
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999)), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999);
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c IS NULL);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NULL), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c IS NULL;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c IS NOT NULL;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c IS NOT NULL);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NOT NULL), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c IS NOT NULL;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c IS NOT NULL;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE);
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE);
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4'));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4')), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE (c like '1%')
+     AND (c not like '3%'));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c like '1%')
+     AND (c not like '3%')), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999));
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999)), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col))), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_long=1
+     AND c='1');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long=1
+     AND c='1'), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long<>1
+  AND c<>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_long<>1
+     AND c<>'1');
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<>1
+     AND c<>'1'), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_long<>1
+  AND c<>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long<>1
+  AND c<>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long>1
+  AND c>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_long>1
+     AND c>'1');
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>1
+     AND c>'1'), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_long>1
+  AND c>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long>1
+  AND c>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long>=1
+  AND c>='1';
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_long>=1
+     AND c>='1');
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>=1
+     AND c>='1'), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_long>=1
+  AND c>='1';
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long>=1
+  AND c>='1';
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long<1
+  AND c<'1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_long<1
+     AND c<'1');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<1
+     AND c<'1'), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_long<1
+  AND c<'1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long<1
+  AND c<'1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long<=1
+  AND c<='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_long<=1
+     AND c<='1');
++---+
+| c |
++---+
+| 1 |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<=1
+     AND c<='1'), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_long<=1
+  AND c<='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long<=1
+  AND c<='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE NOT (c_long<>0
+              AND c_long<>1
+              AND c_long<>2)
+     AND (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999));
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE NOT (c_long<>0
+              AND c_long<>1
+              AND c_long<>2)
+     AND (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999)), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE (c_long=0
+          OR c_long=1
+          OR c_long=2)
+     AND (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999);
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long=0
+          OR c_long=1
+          OR c_long=2)
+     AND (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_str IS NULL
+     AND c IS NULL);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NULL
+     AND c IS NULL), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_str IS NOT NULL
+     AND c IS NOT NULL);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NOT NULL
+     AND c IS NOT NULL), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2) IS TRUE
+     AND c_long IN (3,
+                    4) IS NOT TRUE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE);
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2) IS TRUE
+     AND c_long IN (3,
+                    4) IS NOT TRUE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2) IS NOT FALSE
+     AND c_long IN (3,
+                    4) IS FALSE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE);
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2) IS NOT FALSE
+     AND c_long IN (3,
+                    4) IS FALSE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4'));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4')), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c like '1%')
+     AND (c not like '3%'));
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c like '1%')
+     AND (c not like '3%')), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND c_long NOT IN (3,
+                        4)
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999));
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND c_long NOT IN (3,
+                        4)
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999)), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++----------+
+| c        |
++----------+
+| 1        |
+| 1        |
+| 1        |
+| my_empty |
+| my_empty |
+| my_empty |
+| my_null  |
+| my_null  |
+| my_null  |
++----------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col))), unnest(mv_to_array(c_mv_complex)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long=1;
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_long=1);
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long=1), unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_long=1;
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long=1;
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long<>1;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_long<>1);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<>1), unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_long<>1;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long<>1;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long>1;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_long>1);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>1), unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_long>1;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long>1;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long>=1;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_long>=1);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>=1), unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_long>=1;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long>=1;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long<1;
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_long<1);
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<1), unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_long<1;
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long<1;
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long<=1;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_long<=1);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<=1), unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_long<=1;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long<=1;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE (NOT c_str<>''
+          OR NOT c_str<>'str2'
+          OR NOT c_long<>0
+          OR NOT c_long<>1
+          OR NOT c_long<>2
+          OR NOT c_long<>999)
+     AND (NOT c_str='str3'
+          OR NOT c_str='str4'
+          OR NOT c_long=3
+          OR NOT c_long=4
+          OR NOT c_long=999));
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT c_str<>''
+          OR NOT c_str<>'str2'
+          OR NOT c_long<>0
+          OR NOT c_long<>1
+          OR NOT c_long<>2
+          OR NOT c_long<>999)
+     AND (NOT c_str='str3'
+          OR NOT c_str='str4'
+          OR NOT c_long=3
+          OR NOT c_long=4
+          OR NOT c_long=999)), unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE (c_str=''
+          OR c_str='str2'
+          OR c_long=0
+          OR c_long=1
+          OR c_long=2
+          OR c_long=999)
+     AND NOT c_str='str3'
+     AND NOT c_str='str4'
+     AND NOT c_long=3
+     AND NOT c_long=4
+     AND NOT c_long=999);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str=''
+          OR c_str='str2'
+          OR c_long=0
+          OR c_long=1
+          OR c_long=2
+          OR c_long=999)
+     AND NOT c_str='str3'
+     AND NOT c_str='str4'
+     AND NOT c_long=3
+     AND NOT c_long=4
+     AND NOT c_long=999), unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_str IS NULL;
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_str IS NULL);
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NULL), unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_str IS NULL;
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_str IS NULL;
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_str IS NOT NULL;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_str IS NOT NULL);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NOT NULL), unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_str IS NOT NULL;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_str IS NOT NULL;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS TRUE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS NOT TRUE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS TRUE
+     AND c_long IN (3,
+                    4,
+                    999) IS NOT TRUE);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS TRUE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS NOT TRUE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS TRUE
+     AND c_long IN (3,
+                    4,
+                    999) IS NOT TRUE), unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS NOT FALSE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS FALSE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS NOT FALSE
+     AND c_long IN (3,
+                    4,
+                    999) IS FALSE);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS NOT FALSE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS FALSE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS NOT FALSE
+     AND c_long IN (3,
+                    4,
+                    999) IS FALSE), unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4));
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)), unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c_str not like '%4'));
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c_str not like '%4')), unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++-------------+
+| c           |
++-------------+
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+| my_empty    |
+| my_null     |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B47_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B47_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999)
+     AND c_str NOT IN ('str3',
+                       'str4',
+                       999)
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999)
+     AND c_long NOT IN (3,
+                        4,
+                        999));
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B47_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999)
+     AND c_str NOT IN ('str3',
+                       'str4',
+                       999)
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999)
+     AND c_long NOT IN (3,
+                        4,
+                        999)), unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B47_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B47_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B48_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B48_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c)
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2),(999)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4),(999)) AS t(col)));
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B48_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2),(999)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4),(999)) AS t(col))), unnest(mv_to_array(c_mv_complex)) AS u(c);
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B48_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex)) AS u(c))
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B48_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| my_empty    |
+| my_empty    |
+| my_empty    |
+| my_null     |
+| my_null     |
+| my_null     |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c='1');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c='1'), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c<>'1';
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c<>'1');
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<>'1'), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c<>'1';
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c<>'1';
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c>'1';
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c>'1');
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>'1'), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c>'1';
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c>'1';
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c>='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c>='1');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>='1'), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c>='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c>='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c<'1';
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c<'1');
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<'1'), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c<'1';
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c<'1';
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c<='1';
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c<='1');
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<='1'), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c<='1';
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c<='1';
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999));
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999)), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c IS NULL);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NULL), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c IS NULL;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c IS NOT NULL;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c IS NOT NULL);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NOT NULL), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c IS NOT NULL;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c IS NOT NULL;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(25 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4'));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4')), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE (c like '1%')
+     AND (c not like '3%'));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c like '1%')
+     AND (c not like '3%')), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999));
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999)), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col))), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_long=1
+     AND c='1');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long=1
+     AND c='1'), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long<>1
+  AND c<>'1';
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_long<>1
+     AND c<>'1');
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<>1
+     AND c<>'1'), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_long<>1
+  AND c<>'1';
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long<>1
+  AND c<>'1';
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long>1
+  AND c>'1';
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_long>1
+     AND c>'1');
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>1
+     AND c>'1'), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_long>1
+  AND c>'1';
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long>1
+  AND c>'1';
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long>=1
+  AND c>='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_long>=1
+     AND c>='1');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>=1
+     AND c>='1'), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_long>=1
+  AND c>='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long>=1
+  AND c>='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long<1
+  AND c<'1';
++----+
+| c  |
++----+
+| -1 |
+| 0  |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_long<1
+     AND c<'1');
++----+
+| c  |
++----+
+| -1 |
+| 0  |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<1
+     AND c<'1'), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_long<1
+  AND c<'1';
++----+
+| c  |
++----+
+| -1 |
+| 0  |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long<1
+  AND c<'1';
++----+
+| c  |
++----+
+| -1 |
+| 0  |
++----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long<=1
+  AND c<='1';
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_long<=1
+     AND c<='1');
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<=1
+     AND c<='1'), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_long<=1
+  AND c<='1';
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long<=1
+  AND c<='1';
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
++----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE NOT (c_long<>0
+              AND c_long<>1
+              AND c_long<>2)
+     AND (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999));
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE NOT (c_long<>0
+              AND c_long<>1
+              AND c_long<>2)
+     AND (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999)), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE (c_long=0
+          OR c_long=1
+          OR c_long=2)
+     AND (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long=0
+          OR c_long=1
+          OR c_long=2)
+     AND (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_str IS NULL
+     AND c IS NULL);
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NULL
+     AND c IS NULL), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_str IS NOT NULL
+     AND c IS NOT NULL);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NOT NULL
+     AND c IS NOT NULL), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2) IS TRUE
+     AND c_long IN (3,
+                    4) IS NOT TRUE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2) IS TRUE
+     AND c_long IN (3,
+                    4) IS NOT TRUE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2) IS NOT FALSE
+     AND c_long IN (3,
+                    4) IS FALSE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2) IS NOT FALSE
+     AND c_long IN (3,
+                    4) IS FALSE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4'));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4')), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c like '1%')
+     AND (c not like '3%'));
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c like '1%')
+     AND (c not like '3%')), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND c_long NOT IN (3,
+                        4)
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999));
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND c_long NOT IN (3,
+                        4)
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999)), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
++----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col))), unnest(mv_to_array(c_mv_num)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long=1;
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_long=1);
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long=1), unnest(mv_to_array(c_mv_num)) AS u(c);
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_long=1;
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long=1;
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long<>1;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_long<>1);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<>1), unnest(mv_to_array(c_mv_num)) AS u(c);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_long<>1;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long<>1;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long>1;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_long>1);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>1), unnest(mv_to_array(c_mv_num)) AS u(c);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_long>1;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long>1;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long>=1;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_long>=1);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>=1), unnest(mv_to_array(c_mv_num)) AS u(c);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_long>=1;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long>=1;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long<1;
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_long<1);
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<1), unnest(mv_to_array(c_mv_num)) AS u(c);
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_long<1;
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long<1;
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long<=1;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_long<=1);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<=1), unnest(mv_to_array(c_mv_num)) AS u(c);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_long<=1;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long<=1;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE (NOT c_str<>''
+          OR NOT c_str<>'str2'
+          OR NOT c_long<>0
+          OR NOT c_long<>1
+          OR NOT c_long<>2
+          OR NOT c_long<>999)
+     AND (NOT c_str='str3'
+          OR NOT c_str='str4'
+          OR NOT c_long=3
+          OR NOT c_long=4
+          OR NOT c_long=999));
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT c_str<>''
+          OR NOT c_str<>'str2'
+          OR NOT c_long<>0
+          OR NOT c_long<>1
+          OR NOT c_long<>2
+          OR NOT c_long<>999)
+     AND (NOT c_str='str3'
+          OR NOT c_str='str4'
+          OR NOT c_long=3
+          OR NOT c_long=4
+          OR NOT c_long=999)), unnest(mv_to_array(c_mv_num)) AS u(c);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE (c_str=''
+          OR c_str='str2'
+          OR c_long=0
+          OR c_long=1
+          OR c_long=2
+          OR c_long=999)
+     AND NOT c_str='str3'
+     AND NOT c_str='str4'
+     AND NOT c_long=3
+     AND NOT c_long=4
+     AND NOT c_long=999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str=''
+          OR c_str='str2'
+          OR c_long=0
+          OR c_long=1
+          OR c_long=2
+          OR c_long=999)
+     AND NOT c_str='str3'
+     AND NOT c_str='str4'
+     AND NOT c_long=3
+     AND NOT c_long=4
+     AND NOT c_long=999), unnest(mv_to_array(c_mv_num)) AS u(c);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_str IS NULL;
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_str IS NULL);
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NULL), unnest(mv_to_array(c_mv_num)) AS u(c);
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_str IS NULL;
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_str IS NULL;
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_str IS NOT NULL;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_str IS NOT NULL);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NOT NULL), unnest(mv_to_array(c_mv_num)) AS u(c);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_str IS NOT NULL;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_str IS NOT NULL;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS TRUE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS NOT TRUE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS TRUE
+     AND c_long IN (3,
+                    4,
+                    999) IS NOT TRUE);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS TRUE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS NOT TRUE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS TRUE
+     AND c_long IN (3,
+                    4,
+                    999) IS NOT TRUE), unnest(mv_to_array(c_mv_num)) AS u(c);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS NOT FALSE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS FALSE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS NOT FALSE
+     AND c_long IN (3,
+                    4,
+                    999) IS FALSE);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS NOT FALSE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS FALSE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS NOT FALSE
+     AND c_long IN (3,
+                    4,
+                    999) IS FALSE), unnest(mv_to_array(c_mv_num)) AS u(c);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4));
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)), unnest(mv_to_array(c_mv_num)) AS u(c);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c_str not like '%4'));
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c_str not like '%4')), unnest(mv_to_array(c_mv_num)) AS u(c);
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++----+
+| c  |
++----+
+| -1 |
+| 0  |
+| 1  |
+| 2  |
+| 3  |
++----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B47_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B47_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999)
+     AND c_str NOT IN ('str3',
+                       'str4',
+                       999)
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999)
+     AND c_long NOT IN (3,
+                        4,
+                        999));
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B47_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999)
+     AND c_str NOT IN ('str3',
+                       'str4',
+                       999)
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999)
+     AND c_long NOT IN (3,
+                        4,
+                        999)), unnest(mv_to_array(c_mv_num)) AS u(c);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B47_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B47_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
++----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B48_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B48_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c)
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2),(999)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4),(999)) AS t(col)));
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B48_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2),(999)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4),(999)) AS t(col))), unnest(mv_to_array(c_mv_num)) AS u(c);
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B48_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num)) AS u(c))
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B48_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++----+
+| c  |
++----+
+| -1 |
+| -1 |
+| -1 |
+| 0  |
+| 0  |
+| 0  |
+| 1  |
+| 1  |
+| 1  |
+| 2  |
+| 2  |
+| 2  |
+| 3  |
+| 3  |
+| 3  |
++----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c='1');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c='1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c<>'1';
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+|             |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c<>'1');
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+|             |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<>'1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c<>'1';
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+|             |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c<>'1';
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+|             |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c>'1');
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>'1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c>='1';
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c>='1');
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>='1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c>='1';
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c>='1';
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c<'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c<'1');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<'1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c<'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c<'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c<='1');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<='1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999)), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c IS NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NULL), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c IS NOT NULL;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c IS NOT NULL);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NOT NULL), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c IS NOT NULL;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c IS NOT NULL;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4'));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4')), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE (c like '1%')
+     AND (c not like '3%'));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c like '1%')
+     AND (c not like '3%')), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999)), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col))), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_long=1
+     AND c='1');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long=1
+     AND c='1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long<>1
+  AND c<>'1';
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_long<>1
+     AND c<>'1');
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<>1
+     AND c<>'1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_long<>1
+  AND c<>'1';
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long<>1
+  AND c<>'1';
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long>1
+  AND c>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_long>1
+     AND c>'1');
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>1
+     AND c>'1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_long>1
+  AND c>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long>1
+  AND c>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long>=1
+  AND c>='1';
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_long>=1
+     AND c>='1');
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>=1
+     AND c>='1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_long>=1
+  AND c>='1';
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long>=1
+  AND c>='1';
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long<1
+  AND c<'1';
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_long<1
+     AND c<'1');
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<1
+     AND c<'1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_long<1
+  AND c<'1';
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long<1
+  AND c<'1';
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long<=1
+  AND c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_long<=1
+     AND c<='1');
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<=1
+     AND c<='1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_long<=1
+  AND c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long<=1
+  AND c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE NOT (c_long<>0
+              AND c_long<>1
+              AND c_long<>2)
+     AND (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE NOT (c_long<>0
+              AND c_long<>1
+              AND c_long<>2)
+     AND (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999)), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE (c_long=0
+          OR c_long=1
+          OR c_long=2)
+     AND (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long=0
+          OR c_long=1
+          OR c_long=2)
+     AND (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_str IS NULL
+     AND c IS NULL);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NULL
+     AND c IS NULL), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_str IS NOT NULL
+     AND c IS NOT NULL);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NOT NULL
+     AND c IS NOT NULL), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2) IS TRUE
+     AND c_long IN (3,
+                    4) IS NOT TRUE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2) IS TRUE
+     AND c_long IN (3,
+                    4) IS NOT TRUE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2) IS NOT FALSE
+     AND c_long IN (3,
+                    4) IS FALSE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2) IS NOT FALSE
+     AND c_long IN (3,
+                    4) IS FALSE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4'));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4')), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c like '1%')
+     AND (c not like '3%'));
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c like '1%')
+     AND (c not like '3%')), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND c_long NOT IN (3,
+                        4)
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND c_long NOT IN (3,
+                        4)
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999)), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col))), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long=1;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_long=1);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long=1), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_long=1;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long=1;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long<>1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_long<>1);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<>1), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_long<>1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long<>1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long>1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_long>1);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>1), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_long>1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long>1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long>=1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_long>=1);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>=1), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_long>=1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long>=1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long<1;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_long<1);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<1), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_long<1;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long<1;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long<=1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_long<=1);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<=1), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_long<=1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long<=1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE (NOT c_str<>''
+          OR NOT c_str<>'str2'
+          OR NOT c_long<>0
+          OR NOT c_long<>1
+          OR NOT c_long<>2
+          OR NOT c_long<>999)
+     AND (NOT c_str='str3'
+          OR NOT c_str='str4'
+          OR NOT c_long=3
+          OR NOT c_long=4
+          OR NOT c_long=999));
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT c_str<>''
+          OR NOT c_str<>'str2'
+          OR NOT c_long<>0
+          OR NOT c_long<>1
+          OR NOT c_long<>2
+          OR NOT c_long<>999)
+     AND (NOT c_str='str3'
+          OR NOT c_str='str4'
+          OR NOT c_long=3
+          OR NOT c_long=4
+          OR NOT c_long=999)), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE (c_str=''
+          OR c_str='str2'
+          OR c_long=0
+          OR c_long=1
+          OR c_long=2
+          OR c_long=999)
+     AND NOT c_str='str3'
+     AND NOT c_str='str4'
+     AND NOT c_long=3
+     AND NOT c_long=4
+     AND NOT c_long=999);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str=''
+          OR c_str='str2'
+          OR c_long=0
+          OR c_long=1
+          OR c_long=2
+          OR c_long=999)
+     AND NOT c_str='str3'
+     AND NOT c_str='str4'
+     AND NOT c_long=3
+     AND NOT c_long=4
+     AND NOT c_long=999), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_str IS NULL;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_str IS NULL);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NULL), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_str IS NULL;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_str IS NULL;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_str IS NOT NULL;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_str IS NOT NULL);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NOT NULL), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_str IS NOT NULL;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_str IS NOT NULL;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS TRUE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS NOT TRUE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS TRUE
+     AND c_long IN (3,
+                    4,
+                    999) IS NOT TRUE);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS TRUE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS NOT TRUE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS TRUE
+     AND c_long IN (3,
+                    4,
+                    999) IS NOT TRUE), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS NOT FALSE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS FALSE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS NOT FALSE
+     AND c_long IN (3,
+                    4,
+                    999) IS FALSE);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS NOT FALSE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS FALSE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS NOT FALSE
+     AND c_long IN (3,
+                    4,
+                    999) IS FALSE), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4));
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c_str not like '%4'));
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c_str not like '%4')), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B47_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B47_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999)
+     AND c_str NOT IN ('str3',
+                       'str4',
+                       999)
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999)
+     AND c_long NOT IN (3,
+                        4,
+                        999));
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B47_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999)
+     AND c_str NOT IN ('str3',
+                       'str4',
+                       999)
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999)
+     AND c_long NOT IN (3,
+                        4,
+                        999)), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B47_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B47_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B48_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B48_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2),(999)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4),(999)) AS t(col)));
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B48_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2),(999)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4),(999)) AS t(col))), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B48_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c))
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B48_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c='1');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c='1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c<>'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c<>'1');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<>'1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c<>'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c<>'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c>'1';
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c>'1');
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>'1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c>'1';
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c>'1';
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c>='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c>='1');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>='1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c>='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c>='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c<'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c<'1');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<'1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c<'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c<'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c<='1');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<='1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999)), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c IS NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NULL), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c IS NOT NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NOT NULL), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4'));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4')), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE (c like '1%')
+     AND (c not like '3%'));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c like '1%')
+     AND (c not like '3%')), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999)), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col))), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long=1
+     AND c='1');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long=1
+     AND c='1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long<>1
+  AND c<>'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long<>1
+     AND c<>'1');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<>1
+     AND c<>'1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_long<>1
+  AND c<>'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long<>1
+  AND c<>'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long>1
+  AND c>'1';
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long>1
+     AND c>'1');
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>1
+     AND c>'1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_long>1
+  AND c>'1';
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long>1
+  AND c>'1';
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long>=1
+  AND c>='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long>=1
+     AND c>='1');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>=1
+     AND c>='1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_long>=1
+  AND c>='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long>=1
+  AND c>='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long<1
+  AND c<'1';
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long<1
+     AND c<'1');
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<1
+     AND c<'1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_long<1
+  AND c<'1';
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long<1
+  AND c<'1';
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long<=1
+  AND c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long<=1
+     AND c<='1');
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<=1
+     AND c<='1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_long<=1
+  AND c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long<=1
+  AND c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE NOT (c_long<>0
+              AND c_long<>1
+              AND c_long<>2)
+     AND (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE NOT (c_long<>0
+              AND c_long<>1
+              AND c_long<>2)
+     AND (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999)), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE (c_long=0
+          OR c_long=1
+          OR c_long=2)
+     AND (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long=0
+          OR c_long=1
+          OR c_long=2)
+     AND (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_str IS NULL
+     AND c IS NULL);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NULL
+     AND c IS NULL), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_str IS NOT NULL
+     AND c IS NOT NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NOT NULL
+     AND c IS NOT NULL), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2) IS TRUE
+     AND c_long IN (3,
+                    4) IS NOT TRUE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2) IS TRUE
+     AND c_long IN (3,
+                    4) IS NOT TRUE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2) IS NOT FALSE
+     AND c_long IN (3,
+                    4) IS FALSE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2) IS NOT FALSE
+     AND c_long IN (3,
+                    4) IS FALSE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4'));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4')), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c like '1%')
+     AND (c not like '3%'));
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c like '1%')
+     AND (c not like '3%')), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND c_long NOT IN (3,
+                        4)
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND c_long NOT IN (3,
+                        4)
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999)), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col))), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long=1;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long=1);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long=1), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_long=1;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long=1;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long<>1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long<>1);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<>1), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_long<>1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long<>1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long>1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long>1);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>1), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_long>1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long>1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long>=1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long>=1);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>=1), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_long>=1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long>=1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long<1;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long<1);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<1), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_long<1;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long<1;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long<=1;
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long<=1);
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<=1), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_long<=1;
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long<=1;
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE (NOT c_str<>''
+          OR NOT c_str<>'str2'
+          OR NOT c_long<>0
+          OR NOT c_long<>1
+          OR NOT c_long<>2
+          OR NOT c_long<>999)
+     AND (NOT c_str='str3'
+          OR NOT c_str='str4'
+          OR NOT c_long=3
+          OR NOT c_long=4
+          OR NOT c_long=999));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT c_str<>''
+          OR NOT c_str<>'str2'
+          OR NOT c_long<>0
+          OR NOT c_long<>1
+          OR NOT c_long<>2
+          OR NOT c_long<>999)
+     AND (NOT c_str='str3'
+          OR NOT c_str='str4'
+          OR NOT c_long=3
+          OR NOT c_long=4
+          OR NOT c_long=999)), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE (c_str=''
+          OR c_str='str2'
+          OR c_long=0
+          OR c_long=1
+          OR c_long=2
+          OR c_long=999)
+     AND NOT c_str='str3'
+     AND NOT c_str='str4'
+     AND NOT c_long=3
+     AND NOT c_long=4
+     AND NOT c_long=999);
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str=''
+          OR c_str='str2'
+          OR c_long=0
+          OR c_long=1
+          OR c_long=2
+          OR c_long=999)
+     AND NOT c_str='str3'
+     AND NOT c_str='str4'
+     AND NOT c_long=3
+     AND NOT c_long=4
+     AND NOT c_long=999), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_str IS NULL;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_str IS NULL);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NULL), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_str IS NULL;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_str IS NULL;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_str IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_str IS NOT NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NOT NULL), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_str IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_str IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS TRUE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS NOT TRUE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS TRUE
+     AND c_long IN (3,
+                    4,
+                    999) IS NOT TRUE);
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS TRUE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS NOT TRUE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS TRUE
+     AND c_long IN (3,
+                    4,
+                    999) IS NOT TRUE), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS NOT FALSE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS FALSE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS NOT FALSE
+     AND c_long IN (3,
+                    4,
+                    999) IS FALSE);
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS NOT FALSE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS FALSE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS NOT FALSE
+     AND c_long IN (3,
+                    4,
+                    999) IS FALSE), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c_str not like '%4'));
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c_str not like '%4')), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B47_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B47_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999)
+     AND c_str NOT IN ('str3',
+                       'str4',
+                       999)
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999)
+     AND c_long NOT IN (3,
+                        4,
+                        999));
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B47_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999)
+     AND c_str NOT IN ('str3',
+                       'str4',
+                       999)
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999)
+     AND c_long NOT IN (3,
+                        4,
+                        999)), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B47_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B47_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++---+
+| c |
++---+
+|   |
+|   |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B48_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B48_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2),(999)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4),(999)) AS t(col)));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B48_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2),(999)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4),(999)) AS t(col))), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B48_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c))
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B48_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c='1');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B1_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c='1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c<>'1';
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c<>'1');
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B2_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<>'1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c<>'1';
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c<>'1';
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c>'1');
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B3_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>'1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B3_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B3_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c>='1';
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c>='1');
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B4_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>='1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B4_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c>='1';
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B4_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c>='1';
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c<'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c<'1');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B5_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<'1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B5_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c<'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B5_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c<'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c<='1');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B6_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<='1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B6_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B6_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B7_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999)), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B7_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B7_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B8_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c IS NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B9_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NULL), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B9_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B9_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c IS NOT NULL;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c IS NOT NULL);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B10_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NOT NULL), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B10_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c IS NOT NULL;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B10_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c IS NOT NULL;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B11_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B11_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B11_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B12_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B12_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B12_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B13_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4'));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B13_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4')), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B13_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B13_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE (c like '1%')
+     AND (c not like '3%'));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B14_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c like '1%')
+     AND (c not like '3%')), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B14_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B14_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B15_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B15_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999)), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B15_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B15_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B16_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B16_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B16_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col))), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B16_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B16_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_long=1
+     AND c='1');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B17_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long=1
+     AND c='1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B17_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B17_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long<>1
+  AND c<>'1';
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B18_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_long<>1
+     AND c<>'1');
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B18_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<>1
+     AND c<>'1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B18_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_long<>1
+  AND c<>'1';
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B18_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long<>1
+  AND c<>'1';
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long>1
+  AND c>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_long>1
+     AND c>'1');
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B19_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>1
+     AND c>'1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_long>1
+  AND c>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long>1
+  AND c>'1';
++-------------+
+| c           |
++-------------+
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long>=1
+  AND c>='1';
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_long>=1
+     AND c>='1');
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B20_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>=1
+     AND c>='1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_long>=1
+  AND c>='1';
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long>=1
+  AND c>='1';
++-------------+
+| c           |
++-------------+
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long<1
+  AND c<'1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_long<1
+     AND c<'1');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B21_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<1
+     AND c<'1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B21_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_long<1
+  AND c<'1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B21_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long<1
+  AND c<'1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long<=1
+  AND c<='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B22_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_long<=1
+     AND c<='1');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B22_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<=1
+     AND c<='1'), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B22_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_long<=1
+  AND c<='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B22_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long<=1
+  AND c<='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE NOT (c_long<>0
+              AND c_long<>1
+              AND c_long<>2)
+     AND (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999));
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B23_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE NOT (c_long<>0
+              AND c_long<>1
+              AND c_long<>2)
+     AND (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999)), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B23_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B23_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE (c_long=0
+          OR c_long=1
+          OR c_long=2)
+     AND (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999);
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B24_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long=0
+          OR c_long=1
+          OR c_long=2)
+     AND (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B24_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B24_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B25_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_str IS NULL
+     AND c IS NULL);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B25_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NULL
+     AND c IS NULL), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B25_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B25_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_str IS NOT NULL
+     AND c IS NOT NULL);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B26_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NOT NULL
+     AND c IS NOT NULL), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B26_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B26_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
++-------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B27_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2) IS TRUE
+     AND c_long IN (3,
+                    4) IS NOT TRUE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE);
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B27_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2) IS TRUE
+     AND c_long IN (3,
+                    4) IS NOT TRUE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B27_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B27_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B28_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2) IS NOT FALSE
+     AND c_long IN (3,
+                    4) IS FALSE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE);
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B28_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2) IS NOT FALSE
+     AND c_long IN (3,
+                    4) IS FALSE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B28_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B28_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B29_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B29_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4'));
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B29_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4')), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B29_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B29_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B30_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B30_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c like '1%')
+     AND (c not like '3%'));
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B30_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c like '1%')
+     AND (c not like '3%')), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B30_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B30_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B31_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B31_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND c_long NOT IN (3,
+                        4)
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999));
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B31_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND c_long NOT IN (3,
+                        4)
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999)), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B31_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B31_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B32_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B32_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B32_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col))), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B32_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B32_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B33_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long=1;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B33_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_long=1);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B33_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long=1), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B33_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_long=1;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B33_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long=1;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B34_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long<>1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B34_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_long<>1);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B34_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<>1), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B34_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_long<>1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B34_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long<>1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B35_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long>1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B35_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_long>1);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B35_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>1), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B35_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_long>1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B35_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long>1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B36_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long>=1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B36_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_long>=1);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B36_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>=1), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B36_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_long>=1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B36_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long>=1;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B37_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long<1;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B37_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_long<1);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B37_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<1), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B37_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_long<1;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B37_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long<1;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B38_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long<=1;
++---+
+| c |
++---+
+|   |
+|   |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B38_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_long<=1);
++---+
+| c |
++---+
+|   |
+|   |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B38_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<=1), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B38_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_long<=1;
++---+
+| c |
++---+
+|   |
+|   |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B38_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long<=1;
++---+
+| c |
++---+
+|   |
+|   |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B39_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B39_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE (NOT c_str<>''
+          OR NOT c_str<>'str2'
+          OR NOT c_long<>0
+          OR NOT c_long<>1
+          OR NOT c_long<>2
+          OR NOT c_long<>999)
+     AND (NOT c_str='str3'
+          OR NOT c_str='str4'
+          OR NOT c_long=3
+          OR NOT c_long=4
+          OR NOT c_long=999));
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B39_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT c_str<>''
+          OR NOT c_str<>'str2'
+          OR NOT c_long<>0
+          OR NOT c_long<>1
+          OR NOT c_long<>2
+          OR NOT c_long<>999)
+     AND (NOT c_str='str3'
+          OR NOT c_str='str4'
+          OR NOT c_long=3
+          OR NOT c_long=4
+          OR NOT c_long=999)), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B39_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B39_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B40_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B40_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE (c_str=''
+          OR c_str='str2'
+          OR c_long=0
+          OR c_long=1
+          OR c_long=2
+          OR c_long=999)
+     AND NOT c_str='str3'
+     AND NOT c_str='str4'
+     AND NOT c_long=3
+     AND NOT c_long=4
+     AND NOT c_long=999);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B40_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str=''
+          OR c_str='str2'
+          OR c_long=0
+          OR c_long=1
+          OR c_long=2
+          OR c_long=999)
+     AND NOT c_str='str3'
+     AND NOT c_str='str4'
+     AND NOT c_long=3
+     AND NOT c_long=4
+     AND NOT c_long=999), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B40_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B40_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B41_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_str IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B41_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_str IS NULL);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B41_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NULL), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B41_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_str IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B41_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_str IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B42_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_str IS NOT NULL;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B42_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_str IS NOT NULL);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B42_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NOT NULL), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B42_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_str IS NOT NULL;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B42_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_str IS NOT NULL;
++-------------+
+| c           |
++-------------+
+|             |
+|             |
+|             |
+| 1           |
+| 1           |
+| 1           |
+| [2]         |
+| [2]         |
+| [2]         |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
+|             |
++-------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B43_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B43_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS TRUE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS NOT TRUE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS TRUE
+     AND c_long IN (3,
+                    4,
+                    999) IS NOT TRUE);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B43_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS TRUE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS NOT TRUE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS TRUE
+     AND c_long IN (3,
+                    4,
+                    999) IS NOT TRUE), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B43_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B43_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B44_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B44_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS NOT FALSE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS FALSE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS NOT FALSE
+     AND c_long IN (3,
+                    4,
+                    999) IS FALSE);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B44_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS NOT FALSE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS FALSE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS NOT FALSE
+     AND c_long IN (3,
+                    4,
+                    999) IS FALSE), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B44_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B44_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B45_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B45_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4));
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B45_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B45_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B45_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B46_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B46_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c_str not like '%4'));
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B46_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c_str not like '%4')), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B46_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B46_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
++-------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B47_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B47_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999)
+     AND c_str NOT IN ('str3',
+                       'str4',
+                       999)
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999)
+     AND c_long NOT IN (3,
+                        4,
+                        999));
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B47_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999)
+     AND c_str NOT IN ('str3',
+                       'str4',
+                       999)
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999)
+     AND c_long NOT IN (3,
+                        4,
+                        999)), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B47_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B47_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
++-------------+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B48_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B48_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2),(999)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4),(999)) AS t(col)));
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B48_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2),(999)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4),(999)) AS t(col))), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c);
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B48_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c))
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A5_B48_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_complex_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++-------------+
+| c           |
++-------------+
+|             |
+| 1           |
+| [2]         |
+| [3, [4, 5]] |
+|             |
+|             |
+|             |
++-------------+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c='1');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B1_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c='1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c<>'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c<>'1');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B2_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<>'1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c<>'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c<>'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c>'1';
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c>'1');
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B3_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>'1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B3_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c>'1';
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B3_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c>'1';
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c>='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c>='1');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B4_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>='1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B4_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c>='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B4_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c>='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c<'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c<'1');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B5_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<'1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B5_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c<'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B5_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c<'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c<='1');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B6_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<='1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B6_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B6_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B7_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999)), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B7_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B7_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B8_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c IS NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B9_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NULL), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B9_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B9_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c IS NOT NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B10_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NOT NULL), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B10_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B10_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B11_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B11_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B11_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B12_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B12_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B12_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B13_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4'));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B13_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4')), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B13_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B13_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE (c like '1%')
+     AND (c not like '3%'));
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B14_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c like '1%')
+     AND (c not like '3%')), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B14_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B14_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B15_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B15_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999)), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B15_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B15_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B16_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B16_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B16_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col))), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B16_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B16_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_long=1
+     AND c='1');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B17_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long=1
+     AND c='1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B17_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B17_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long<>1
+  AND c<>'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B18_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_long<>1
+     AND c<>'1');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B18_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<>1
+     AND c<>'1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B18_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_long<>1
+  AND c<>'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B18_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long<>1
+  AND c<>'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long>1
+  AND c>'1';
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_long>1
+     AND c>'1');
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B19_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>1
+     AND c>'1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_long>1
+  AND c>'1';
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long>1
+  AND c>'1';
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long>=1
+  AND c>='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_long>=1
+     AND c>='1');
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B20_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>=1
+     AND c>='1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_long>=1
+  AND c>='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long>=1
+  AND c>='1';
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long<1
+  AND c<'1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_long<1
+     AND c<'1');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B21_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<1
+     AND c<'1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B21_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_long<1
+  AND c<'1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B21_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long<1
+  AND c<'1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long<=1
+  AND c<='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B22_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_long<=1
+     AND c<='1');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B22_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<=1
+     AND c<='1'), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B22_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_long<=1
+  AND c<='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B22_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long<=1
+  AND c<='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE NOT (c_long<>0
+              AND c_long<>1
+              AND c_long<>2)
+     AND (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999));
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B23_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE NOT (c_long<>0
+              AND c_long<>1
+              AND c_long<>2)
+     AND (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999)), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B23_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B23_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE (c_long=0
+          OR c_long=1
+          OR c_long=2)
+     AND (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999);
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B24_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long=0
+          OR c_long=1
+          OR c_long=2)
+     AND (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B24_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B24_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B25_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_str IS NULL
+     AND c IS NULL);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B25_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NULL
+     AND c IS NULL), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B25_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B25_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_str IS NOT NULL
+     AND c IS NOT NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B26_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NOT NULL
+     AND c IS NOT NULL), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B26_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B26_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
++---+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B27_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2) IS TRUE
+     AND c_long IN (3,
+                    4) IS NOT TRUE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE);
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B27_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2) IS TRUE
+     AND c_long IN (3,
+                    4) IS NOT TRUE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B27_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B27_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B28_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2) IS NOT FALSE
+     AND c_long IN (3,
+                    4) IS FALSE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE);
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B28_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2) IS NOT FALSE
+     AND c_long IN (3,
+                    4) IS FALSE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B28_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B28_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B29_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B29_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4'));
++---+
+| c |
++---+
+| 1 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B29_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4')), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B29_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B29_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
+| 1 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B30_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B30_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c like '1%')
+     AND (c not like '3%'));
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B30_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c like '1%')
+     AND (c not like '3%')), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B30_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B30_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B31_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B31_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND c_long NOT IN (3,
+                        4)
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999));
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B31_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND c_long NOT IN (3,
+                        4)
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999)), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B31_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B31_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+| 1 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B32_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B32_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B32_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col))), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B32_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B32_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B33_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long=1;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B33_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_long=1);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B33_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long=1), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B33_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_long=1;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B33_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long=1;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B34_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long<>1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B34_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_long<>1);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B34_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<>1), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B34_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_long<>1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B34_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long<>1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B35_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long>1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B35_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_long>1);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B35_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>1), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B35_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_long>1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B35_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long>1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B36_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long>=1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B36_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_long>=1);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B36_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>=1), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B36_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_long>=1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B36_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long>=1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B37_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long<1;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B37_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_long<1);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B37_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<1), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B37_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_long<1;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B37_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long<1;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B38_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long<=1;
++---+
+| c |
++---+
+|   |
+|   |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B38_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_long<=1);
++---+
+| c |
++---+
+|   |
+|   |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B38_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<=1), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B38_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_long<=1;
++---+
+| c |
++---+
+|   |
+|   |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B38_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long<=1;
++---+
+| c |
++---+
+|   |
+|   |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B39_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B39_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE (NOT c_str<>''
+          OR NOT c_str<>'str2'
+          OR NOT c_long<>0
+          OR NOT c_long<>1
+          OR NOT c_long<>2
+          OR NOT c_long<>999)
+     AND (NOT c_str='str3'
+          OR NOT c_str='str4'
+          OR NOT c_long=3
+          OR NOT c_long=4
+          OR NOT c_long=999));
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B39_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT c_str<>''
+          OR NOT c_str<>'str2'
+          OR NOT c_long<>0
+          OR NOT c_long<>1
+          OR NOT c_long<>2
+          OR NOT c_long<>999)
+     AND (NOT c_str='str3'
+          OR NOT c_str='str4'
+          OR NOT c_long=3
+          OR NOT c_long=4
+          OR NOT c_long=999)), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B39_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B39_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B40_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B40_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE (c_str=''
+          OR c_str='str2'
+          OR c_long=0
+          OR c_long=1
+          OR c_long=2
+          OR c_long=999)
+     AND NOT c_str='str3'
+     AND NOT c_str='str4'
+     AND NOT c_long=3
+     AND NOT c_long=4
+     AND NOT c_long=999);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B40_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str=''
+          OR c_str='str2'
+          OR c_long=0
+          OR c_long=1
+          OR c_long=2
+          OR c_long=999)
+     AND NOT c_str='str3'
+     AND NOT c_str='str4'
+     AND NOT c_long=3
+     AND NOT c_long=4
+     AND NOT c_long=999), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B40_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B40_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B41_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_str IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B41_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_str IS NULL);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B41_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NULL), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B41_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_str IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B41_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_str IS NULL;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B42_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_str IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B42_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_str IS NOT NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B42_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NOT NULL), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B42_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_str IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B42_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_str IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+| 1 |
+| 1 |
+| 1 |
+| 2 |
+| 2 |
+| 2 |
+| 3 |
+| 3 |
+| 3 |
+|   |
+|   |
+|   |
+|   |
++---+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B43_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B43_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS TRUE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS NOT TRUE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS TRUE
+     AND c_long IN (3,
+                    4,
+                    999) IS NOT TRUE);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B43_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS TRUE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS NOT TRUE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS TRUE
+     AND c_long IN (3,
+                    4,
+                    999) IS NOT TRUE), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B43_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B43_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B44_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B44_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS NOT FALSE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS FALSE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS NOT FALSE
+     AND c_long IN (3,
+                    4,
+                    999) IS FALSE);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B44_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS NOT FALSE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS FALSE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS NOT FALSE
+     AND c_long IN (3,
+                    4,
+                    999) IS FALSE), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B44_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B44_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B45_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B45_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4));
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B45_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B45_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B45_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B46_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B46_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c_str not like '%4'));
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B46_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c_str not like '%4')), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B46_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B46_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B47_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B47_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999)
+     AND c_str NOT IN ('str3',
+                       'str4',
+                       999)
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999)
+     AND c_long NOT IN (3,
+                        4,
+                        999));
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B47_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999)
+     AND c_str NOT IN ('str3',
+                       'str4',
+                       999)
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999)
+     AND c_long NOT IN (3,
+                        4,
+                        999)), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B47_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B47_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B48_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B48_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2),(999)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4),(999)) AS t(col)));
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B48_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2),(999)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4),(999)) AS t(col))), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c);
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B48_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c))
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A6_B48_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_num_with_null_and_empty_row)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++---+
+| c |
++---+
+|   |
+| 1 |
+| 2 |
+| 3 |
+|   |
+|   |
+|   |
++---+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c='1');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B1_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c='1'), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c<>'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c<>'1');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B2_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<>'1'), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c<>'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c<>'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c>'1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c>'1');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B3_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>'1'), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B3_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c>'1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B3_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c>'1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c>='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c>='1');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B4_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c>='1'), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B4_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c>='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B4_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c>='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c<'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c<'1');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B5_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<'1'), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B5_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c<'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B5_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c<'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c<='1');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B6_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c<='1'), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B6_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B6_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B7_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999)), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B7_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B7_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B8_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c IS NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B9_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NULL), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B9_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B9_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c IS NOT NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B10_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IS NOT NULL), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B10_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B10_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B11_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B11_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B11_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B12_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B12_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B12_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B13_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4'));
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B13_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4')), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B13_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B13_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE (c like '1%')
+     AND (c not like '3%'));
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B14_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c like '1%')
+     AND (c not like '3%')), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B14_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B14_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B15_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B15_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999)), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B15_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B15_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B16_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B16_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B16_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col))), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B16_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B16_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_long=1
+     AND c='1');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B17_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long=1
+     AND c='1'), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B17_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B17_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long=1
+  AND c='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long<>1
+  AND c<>'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B18_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_long<>1
+     AND c<>'1');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B18_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<>1
+     AND c<>'1'), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B18_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_long<>1
+  AND c<>'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B18_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long<>1
+  AND c<>'1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long>1
+  AND c>'1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_long>1
+     AND c>'1');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B19_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>1
+     AND c>'1'), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_long>1
+  AND c>'1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long>1
+  AND c>'1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long>=1
+  AND c>='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_long>=1
+     AND c>='1');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B20_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>=1
+     AND c>='1'), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_long>=1
+  AND c>='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long>=1
+  AND c>='1';
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long<1
+  AND c<'1';
++---+
+| c |
++---+
+|   |
+|   |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_long<1
+     AND c<'1');
++---+
+| c |
++---+
+|   |
+|   |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B21_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<1
+     AND c<'1'), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B21_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_long<1
+  AND c<'1';
++---+
+| c |
++---+
+|   |
+|   |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B21_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long<1
+  AND c<'1';
++---+
+| c |
++---+
+|   |
+|   |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long<=1
+  AND c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B22_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_long<=1
+     AND c<='1');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B22_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<=1
+     AND c<='1'), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B22_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_long<=1
+  AND c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B22_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long<=1
+  AND c<='1';
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE NOT (c_long<>0
+              AND c_long<>1
+              AND c_long<>2)
+     AND (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B23_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE NOT (c_long<>0
+              AND c_long<>1
+              AND c_long<>2)
+     AND (NOT c<>''
+          OR NOT c<>'my_null'
+          OR NOT c<>'my_empty'
+          OR NOT c<>'1'
+          OR NOT c<>'-1'
+          OR NOT c<>'0'
+          OR NOT c<>'999'
+          OR NOT c<>999)
+     AND (NOT c='[2]'
+          OR NOT c='[3, [4, 5]]'
+          OR NOT c='2'
+          OR NOT c='3'
+          OR NOT c='999'
+          OR NOT c=999)), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B23_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B23_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE NOT (c_long<>0
+           AND c_long<>1
+           AND c_long<>2)
+  AND (NOT c<>''
+       OR NOT c<>'my_null'
+       OR NOT c<>'my_empty'
+       OR NOT c<>'1'
+       OR NOT c<>'-1'
+       OR NOT c<>'0'
+       OR NOT c<>'999'
+       OR NOT c<>999)
+  AND (NOT c='[2]'
+       OR NOT c='[3, [4, 5]]'
+       OR NOT c='2'
+       OR NOT c='3'
+       OR NOT c='999'
+       OR NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE (c_long=0
+          OR c_long=1
+          OR c_long=2)
+     AND (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B24_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long=0
+          OR c_long=1
+          OR c_long=2)
+     AND (c=''
+          OR c='my_null'
+          OR c='my_empty'
+          OR c='1'
+          OR c='-1'
+          OR c='0'
+          OR c='999'
+          OR c=999)
+     AND NOT c='[2]'
+     AND NOT c='[3, [4, 5]]'
+     AND NOT c='2'
+     AND NOT c='3'
+     AND NOT c='999'
+     AND NOT c=999), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B24_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B24_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (c_long=0
+       OR c_long=1
+       OR c_long=2)
+  AND (c=''
+       OR c='my_null'
+       OR c='my_empty'
+       OR c='1'
+       OR c='-1'
+       OR c='0'
+       OR c='999'
+       OR c=999)
+  AND NOT c='[2]'
+  AND NOT c='[3, [4, 5]]'
+  AND NOT c='2'
+  AND NOT c='3'
+  AND NOT c='999'
+  AND NOT c=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B25_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_str IS NULL
+     AND c IS NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B25_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NULL
+     AND c IS NULL), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B25_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B25_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_str IS NULL
+  AND c IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_str IS NOT NULL
+     AND c IS NOT NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B26_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NOT NULL
+     AND c IS NOT NULL), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B26_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B26_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_str IS NOT NULL
+  AND c IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B27_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2) IS TRUE
+     AND c_long IN (3,
+                    4) IS NOT TRUE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B27_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2) IS TRUE
+     AND c_long IN (3,
+                    4) IS NOT TRUE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS TRUE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS NOT TRUE), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B27_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B27_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS TRUE
+  AND c_long IN (3,
+                 4) IS NOT TRUE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS TRUE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B28_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2) IS NOT FALSE
+     AND c_long IN (3,
+                    4) IS FALSE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B28_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2) IS NOT FALSE
+     AND c_long IN (3,
+                    4) IS FALSE
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999) IS NOT FALSE
+     AND c IN ('[2]',
+               '[3, [4, 5]]',
+               '2',
+               '3',
+               '999',
+               999) IS FALSE), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B28_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B28_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2) IS NOT FALSE
+  AND c_long IN (3,
+                 4) IS FALSE
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999) IS NOT FALSE
+  AND c IN ('[2]',
+            '[3, [4, 5]]',
+            '2',
+            '3',
+            '999',
+            999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B29_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B29_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4'));
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B29_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)
+     AND (c BETWEEN '1' AND '2')
+     AND (c NOT BETWEEN '3' AND '4')), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B29_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B29_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4)
+  AND (c BETWEEN '1' AND '2')
+  AND (c NOT BETWEEN '3' AND '4');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B30_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B30_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c like '1%')
+     AND (c not like '3%'));
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B30_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c like '1%')
+     AND (c not like '3%')), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B30_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B30_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c like '1%')
+  AND (c not like '3%');
++---+
+| c |
++---+
++---+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B31_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B31_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND c_long NOT IN (3,
+                        4)
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B31_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND c_long NOT IN (3,
+                        4)
+     AND c IN ('',
+               'my_null',
+               'my_empty',
+               '1',
+               '-1',
+               '0',
+               '999',
+               999)
+     AND c NOT IN ('[2]',
+                   '[3, [4, 5]]',
+                   '2',
+                   '3',
+                   '999',
+                   999)), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B31_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B31_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND c_long NOT IN (3,
+                     4)
+  AND c IN ('',
+            'my_null',
+            'my_empty',
+            '1',
+            '-1',
+            '0',
+            '999',
+            999)
+  AND c NOT IN ('[2]',
+                '[3, [4, 5]]',
+                '2',
+                '3',
+                '999',
+                999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B32_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B32_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col)));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B32_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4)) AS t(col))
+     AND c IN
+       (SELECT col
+        FROM (
+              VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+     AND c NOT IN
+       (SELECT col
+        FROM (
+              VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col))), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B32_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B32_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4)) AS t(col))
+  AND c IN
+    (SELECT col
+     FROM (
+           VALUES(''),('my_null'),('my_empty'),('1'),('-1'),('0'),('999')) AS t(col))
+  AND c NOT IN
+    (SELECT col
+     FROM (
+           VALUES('[2]'),('[3, [4, 5]]'),('2'),('3'),('999')) AS t(col));
+Unhandled Query Planning Failure
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B33_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long=1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B33_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_long=1);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B33_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long=1), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B33_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_long=1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B33_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long=1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B34_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long<>1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B34_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_long<>1);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B34_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<>1), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B34_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_long<>1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B34_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long<>1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B35_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long>1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B35_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_long>1);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B35_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>1), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B35_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_long>1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B35_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long>1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B36_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long>=1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B36_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_long>=1);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B36_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long>=1), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B36_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_long>=1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B36_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long>=1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B37_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long<1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B37_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_long<1);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B37_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<1), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B37_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_long<1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B37_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long<1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B38_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long<=1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B38_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_long<=1);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B38_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long<=1), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B38_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_long<=1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B38_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long<=1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B39_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B39_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE (NOT c_str<>''
+          OR NOT c_str<>'str2'
+          OR NOT c_long<>0
+          OR NOT c_long<>1
+          OR NOT c_long<>2
+          OR NOT c_long<>999)
+     AND (NOT c_str='str3'
+          OR NOT c_str='str4'
+          OR NOT c_long=3
+          OR NOT c_long=4
+          OR NOT c_long=999));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B39_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (NOT c_str<>''
+          OR NOT c_str<>'str2'
+          OR NOT c_long<>0
+          OR NOT c_long<>1
+          OR NOT c_long<>2
+          OR NOT c_long<>999)
+     AND (NOT c_str='str3'
+          OR NOT c_str='str4'
+          OR NOT c_long=3
+          OR NOT c_long=4
+          OR NOT c_long=999)), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B39_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B39_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (NOT c_str<>''
+       OR NOT c_str<>'str2'
+       OR NOT c_long<>0
+       OR NOT c_long<>1
+       OR NOT c_long<>2
+       OR NOT c_long<>999)
+  AND (NOT c_str='str3'
+       OR NOT c_str='str4'
+       OR NOT c_long=3
+       OR NOT c_long=4
+       OR NOT c_long=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B40_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B40_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE (c_str=''
+          OR c_str='str2'
+          OR c_long=0
+          OR c_long=1
+          OR c_long=2
+          OR c_long=999)
+     AND NOT c_str='str3'
+     AND NOT c_str='str4'
+     AND NOT c_long=3
+     AND NOT c_long=4
+     AND NOT c_long=999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B40_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str=''
+          OR c_str='str2'
+          OR c_long=0
+          OR c_long=1
+          OR c_long=2
+          OR c_long=999)
+     AND NOT c_str='str3'
+     AND NOT c_str='str4'
+     AND NOT c_long=3
+     AND NOT c_long=4
+     AND NOT c_long=999), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B40_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B40_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (c_str=''
+       OR c_str='str2'
+       OR c_long=0
+       OR c_long=1
+       OR c_long=2
+       OR c_long=999)
+  AND NOT c_str='str3'
+  AND NOT c_str='str4'
+  AND NOT c_long=3
+  AND NOT c_long=4
+  AND NOT c_long=999;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B41_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_str IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B41_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_str IS NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B41_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NULL), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B41_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_str IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B41_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_str IS NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B42_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_str IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B42_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_str IS NOT NULL);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B42_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IS NOT NULL), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B42_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_str IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B42_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_str IS NOT NULL;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(20 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B43_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B43_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS TRUE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS NOT TRUE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS TRUE
+     AND c_long IN (3,
+                    4,
+                    999) IS NOT TRUE);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B43_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS TRUE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS NOT TRUE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS TRUE
+     AND c_long IN (3,
+                    4,
+                    999) IS NOT TRUE), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B43_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B43_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS TRUE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS NOT TRUE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS TRUE
+  AND c_long IN (3,
+                 4,
+                 999) IS NOT TRUE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B44_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B44_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS NOT FALSE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS FALSE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS NOT FALSE
+     AND c_long IN (3,
+                    4,
+                    999) IS FALSE);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B44_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999) IS NOT FALSE
+     AND c_str IN ('str3',
+                   'str4',
+                   999) IS FALSE
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999) IS NOT FALSE
+     AND c_long IN (3,
+                    4,
+                    999) IS FALSE), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B44_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B44_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999) IS NOT FALSE
+  AND c_str IN ('str3',
+                'str4',
+                999) IS FALSE
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999) IS NOT FALSE
+  AND c_long IN (3,
+                 4,
+                 999) IS FALSE;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B45_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B45_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B45_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_long BETWEEN 0 AND 2)
+     AND (c_long NOT BETWEEN 3 AND 4)), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B45_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B45_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (c_long BETWEEN 0 AND 2)
+  AND (c_long NOT BETWEEN 3 AND 4);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B46_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B46_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c_str not like '%4'));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B46_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE (c_str like '%2')
+     AND (c_str not like '%3')
+     AND (c_str not like '%4')), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B46_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B46_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE (c_str like '%2')
+  AND (c_str not like '%3')
+  AND (c_str not like '%4');
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B47_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B47_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_str IN ('',
+                   'str2',
+                   999)
+     AND c_str NOT IN ('str3',
+                       'str4',
+                       999)
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999)
+     AND c_long NOT IN (3,
+                        4,
+                        999));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B47_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_str IN ('',
+                   'str2',
+                   999)
+     AND c_str NOT IN ('str3',
+                       'str4',
+                       999)
+     AND c_long IN (0,
+                    1,
+                    2,
+                    999)
+     AND c_long NOT IN (3,
+                        4,
+                        999)), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B47_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B47_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_str IN ('',
+                'str2',
+                999)
+  AND c_str NOT IN ('str3',
+                    'str4',
+                    999)
+  AND c_long IN (0,
+                 1,
+                 2,
+                 999)
+  AND c_long NOT IN (3,
+                     4,
+                     999);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B48_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B48_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2),(999)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4),(999)) AS t(col)));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B48_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest
+   WHERE c_long IN
+       (SELECT col
+        FROM (
+              VALUES(0),(1),(2),(999)) AS t(col))
+     AND c_long NOT IN
+       (SELECT col
+        FROM (
+              VALUES(3),(4),(999)) AS t(col))), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B48_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c))
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B48_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT *
+   FROM test_unnest), unnest(mv_to_array(c_mv_all_null_and_empty_val)) AS u(c)
+WHERE c_long IN
+    (SELECT col
+     FROM (
+           VALUES(0),(1),(2),(999)) AS t(col))
+  AND c_long NOT IN
+    (SELECT col
+     FROM (
+           VALUES(3),(4),(999)) AS t(col));
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 1681 Positive tests: 1401 Negative tests: 280
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql_ops.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql_ops.iq
new file mode 100644
index 000000000000..def661788623
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql_ops.iq
@@ -0,0 +1,331 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaUnnest/mv&numMergeBuffers=3
+!set outputformat mysql
+SELECT *
+FROM test_unnest;
++-------------------------+-------+--------+---------+----------+------------------------------------------------+------------------------+--------------------------------------+----------------------------------+--------------------------------------+----------------------------------+-----------------------------+
+| __time                  | c_str | c_long | c_float | c_double | c_mv_complex                                   | c_mv_num               | c_mv_complex_with_null_and_empty_val | c_mv_num_with_null_and_empty_val | c_mv_complex_with_null_and_empty_row | c_mv_num_with_null_and_empty_row | c_mv_all_null_and_empty_val |
++-------------------------+-------+--------+---------+----------+------------------------------------------------+------------------------+--------------------------------------+----------------------------------+--------------------------------------+----------------------------------+-----------------------------+
+| 2022-01-01 00:00:00.000 |       |      1 |     0.1 |      0.1 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 | str2  |      2 |     0.2 |      0.2 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 | str3  |      3 |     0.3 |      0.3 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 | str4  |      4 |     0.4 |      0.4 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 |       |      0 |     0.0 |      0.0 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      |
++-------------------------+-------+--------+---------+----------+------------------------------------------------+------------------------+--------------------------------------+----------------------------------+--------------------------------------+----------------------------------+-----------------------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c+c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (c+c) IN (0,
+                2,
+                4,
+                6);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+| 6.0 |
+| 6.0 |
+| 6.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|   2 |
+|   3 |
+|   3 |
+|   3 |
+|   4 |
+|   4 |
+|   5 |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c-c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (c-c)=0;
++-----+
+| col |
++-----+
+| 0.0 |
+| 0.0 |
+| 0.0 |
+| 0.0 |
+| 0.0 |
+| 0.0 |
+| 0.0 |
+| 0.0 |
+| 0.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c-c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----+
+| col |
++-----+
+|  -1 |
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   3 |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c*c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (c*c) IN (0,
+                1,
+                4,
+                9);
++-----+
+| col |
++-----+
+| 1.0 |
+| 1.0 |
+| 1.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+| 9.0 |
+| 9.0 |
+| 9.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c*c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   1 |
+|   2 |
+|   2 |
+|   3 |
+|   4 |
+|   6 |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c/c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (c/c)=1;
++-----+
+| col |
++-----+
+| 1.0 |
+| 1.0 |
+| 1.0 |
+| 1.0 |
+| 1.0 |
+| 1.0 |
+| 1.0 |
+| 1.0 |
+| 1.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c/c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (1,
+                 2);
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   3 |
+|     |
+|     |
+|     |
+|     |
++-----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A2_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c||c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (c||c) IN ('',
+                 '11',
+                 '22',
+                 '33');
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 11  |
+| 11  |
+| 11  |
+| 22  |
+| 22  |
+| 22  |
+| 33  |
+| 33  |
+| 33  |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A2_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c||c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (c||c_long) IN ('0',
+                      '10',
+                      '20',
+                      '30',
+                      '1',
+                      '11',
+                      '21',
+                      '31',
+                      '2',
+                      '12',
+                      '22',
+                      '32');
++-----+
+| col |
++-----+
+| 0   |
+| 1   |
+| 10  |
+| 11  |
+| 12  |
+| 2   |
+| 20  |
+| 21  |
+| 22  |
+| 30  |
+| 31  |
+| 32  |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 11 Positive tests: 11 Negative tests: 0
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql_other_funcs.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql_other_funcs.iq
new file mode 100644
index 000000000000..2f3b61e8c223
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql_other_funcs.iq
@@ -0,0 +1,7720 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaUnnest/mv&numMergeBuffers=3
+!set outputformat mysql
+SELECT *
+FROM test_unnest;
++-------------------------+-------+--------+---------+----------+------------------------------------------------+------------------------+--------------------------------------+----------------------------------+--------------------------------------+----------------------------------+-----------------------------+
+| __time                  | c_str | c_long | c_float | c_double | c_mv_complex                                   | c_mv_num               | c_mv_complex_with_null_and_empty_val | c_mv_num_with_null_and_empty_val | c_mv_complex_with_null_and_empty_row | c_mv_num_with_null_and_empty_row | c_mv_all_null_and_empty_val |
++-------------------------+-------+--------+---------+----------+------------------------------------------------+------------------------+--------------------------------------+----------------------------------+--------------------------------------+----------------------------------+-----------------------------+
+| 2022-01-01 00:00:00.000 |       |      1 |     0.1 |      0.1 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 | str2  |      2 |     0.2 |      0.2 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 | str3  |      3 |     0.3 |      0.3 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 | str4  |      4 |     0.4 |      0.4 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 |       |      0 |     0.0 |      0.0 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      |
++-------------------------+-------+--------+---------+----------+------------------------------------------------+------------------------+--------------------------------------+----------------------------------+--------------------------------------+----------------------------------+-----------------------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----+
+| col |
++-----+
+|  15 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----+
+| col |
++-----+
+|   5 |
+|   5 |
+|   5 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING count(*) IN (3,
+                    6);
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING count(*) IN (5);
++-----+
+| col |
++-----+
+|   5 |
+|   5 |
+|   5 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----+
+| col |
++-----+
+|   4 |
+|   4 |
+|   4 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING count(DISTINCT c) IN (0,
+                             1);
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING count(DISTINCT c) IN (3,
+                             4);
++-----+
+| col |
++-----+
+|   4 |
+|   4 |
+|   4 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING count(DISTINCT c_long) IN (3);
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING count(DISTINCT c_long) IN (1);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++------+
+| col  |
++------+
+| 18.0 |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----+
+| col |
++-----+
+|  15 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-----+
+| col |
++-----+
+| 3.0 |
+| 6.0 |
+| 9.0 |
+|     |
+|     |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----+
+| col |
++-----+
+| 6.0 |
+| 6.0 |
+| 6.0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----+
+| col |
++-----+
+|   0 |
+|  10 |
+|   5 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING sum(c) IN (0,
+                  3,
+                  6,
+                  9);
++-----+
+| col |
++-----+
+| 3.0 |
+| 6.0 |
+| 9.0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING sum(c) IN (6);
++-----+
+| col |
++-----+
+| 6.0 |
+| 6.0 |
+| 6.0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING sum(c_long) IN (3,
+                       6);
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING sum(c_long) IN (0,
+                       5,
+                       10);
++-----+
+| col |
++-----+
+|   0 |
+|  10 |
+|   5 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING min(c) IN (0,
+                  1,
+                  2);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING min(c) IN (0,
+                  1,
+                  2);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING min(c_long) IN (0);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING min(c_long) IN (0,
+                       1,
+                       2);
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING max(c) IN (0,
+                  1,
+                  2);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING max(c) IN (0,
+                  1,
+                  2);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING max(c_long) IN (2);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING max(c_long) IN (0,
+                       1,
+                       2);
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----+
+| col |
++-----+
+| 2.0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----+
+| col |
++-----+
+| 1.0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-----+
+| col |
++-----+
+| 1.0 |
+| 2.0 |
+| 3.0 |
+|     |
+|     |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-----+
+| col |
++-----+
+| 1.0 |
+| 1.0 |
+| 1.0 |
+| 1.0 |
+| 1.0 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----+
+| col |
++-----+
+| 0.0 |
+| 1.0 |
+| 2.0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING avg(c) IS NULL
+OR cast(avg(c) AS char) IN ('NaN',
+                            '1.0',
+                            '2.0',
+                            '3.0');
++-----+
+| col |
++-----+
+| 1.0 |
+| 2.0 |
+| 3.0 |
+|     |
+|     |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING avg(c) IN (2.0,
+                  1.2);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING avg(c_long) IN (1);
++-----+
+| col |
++-----+
+| 1.0 |
+| 1.0 |
+| 1.0 |
+| 1.0 |
+| 1.0 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING avg(c_long) IN (0,
+                       1,
+                       2);
++-----+
+| col |
++-----+
+| 0.0 |
+| 1.0 |
+| 2.0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING approx_count_distinct(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING approx_count_distinct(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING approx_count_distinct(c_long) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING approx_count_distinct(c_long) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING approx_count_distinct_builtin(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING approx_count_distinct_builtin(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING approx_count_distinct_builtin(c_long) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT approx_count_distinct_builtin(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING approx_count_distinct_builtin(c_long) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(cast(c AS int)) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(cast(c AS int)) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(cast(c AS int)) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(cast(c AS int)) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING earliest(cast(c AS int)) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(cast(c AS int)) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING earliest(cast(c AS int)) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING earliest(c_long) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING earliest(c_long) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c, 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(cast(c_long AS char), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c, 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c, 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(cast(c_long AS char), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(cast(c_long AS char), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c, 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING earliest(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(c, 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING earliest(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(cast(c_long AS char), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING earliest(cast(c_long AS char), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest(cast(c_long AS char), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING earliest(cast(c_long AS char), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(cast(c AS int), time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c_long, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(cast(c AS int), time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(cast(c AS int), time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c_long, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c_long, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(cast(c AS int), time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING earliest_by(cast(c AS int), time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(cast(c AS int), time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING earliest_by(cast(c AS int), time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c_long, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING earliest_by(c_long, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c_long, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING earliest_by(c_long, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(cast(c_long AS char), time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(cast(c_long AS char), time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(cast(c_long AS char), time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING earliest_by(c, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING earliest_by(c, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(cast(c_long AS char), time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING earliest_by(cast(c_long AS char), time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT earliest_by(cast(c_long AS char), time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING earliest_by(cast(c_long AS char), time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(cast(c AS int)) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(cast(c AS int)) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(cast(c AS int)) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(cast(c AS int)) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING latest(cast(c AS int)) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(cast(c AS int)) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING latest(cast(c AS int)) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING latest(c_long) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING latest(c_long) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c, 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(cast(c_long AS char), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c, 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c, 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(cast(c_long AS char), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(cast(c_long AS char), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c, 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING latest(c, 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(c, 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING latest(c, 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(cast(c_long AS char), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING latest(cast(c_long AS char), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest(cast(c_long AS char), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING latest(cast(c_long AS char), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(cast(c AS int), time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c_long, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(cast(c AS int), time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(cast(c AS int), time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c_long, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c_long, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(cast(c AS int), time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING latest_by(cast(c AS int), time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(cast(c AS int), time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING latest_by(cast(c AS int), time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c_long, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING latest_by(c_long, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c_long, time_floor(__time, 'P1D')) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING latest_by(c_long, time_floor(__time, 'P1D')) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(cast(c_long AS char), time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(cast(c_long AS char), time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(cast(c_long AS char), time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING latest_by(c, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(c, time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING latest_by(c, time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(cast(c_long AS char), time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING latest_by(cast(c_long AS char), time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT latest_by(cast(c_long AS char), time_floor(__time, 'P1D'), 100) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING latest_by(cast(c_long AS char), time_floor(__time, 'P1D'), 100) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2));
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING any_value(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING any_value(c) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c
+   HAVING any_value(c_long) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   5 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT any_value(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+   GROUP BY c_long
+   HAVING any_value(c_long) IS NOT NULL);
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c col,
+       count(*) cnt,
+       grouping(c) gp
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long col,
+       count(*) cnt,
+       grouping(c_long) gp
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c col,
+       count(*) cnt,
+       grouping(c) gp
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-----+-----+----+
+| col | cnt | gp |
++-----+-----+----+
+|     |   3 |  0 |
+| 1   |   3 |  0 |
+| 2   |   3 |  0 |
+| 3   |   3 |  0 |
+|     |   3 |  0 |
++-----+-----+----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c col,
+       count(*) cnt,
+       grouping(c) gp
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long col,
+       count(*) cnt,
+       grouping(c_long) gp
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long col,
+       count(*) cnt,
+       grouping(c_long) gp
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----+-----+----+
+| col | cnt | gp |
++-----+-----+----+
+|   0 |   5 |  0 |
+|   1 |   5 |  0 |
+|   2 |   5 |  0 |
++-----+-----+----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c col,
+       count(*) cnt,
+       grouping(c) gp
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING grouping(c) IS NOT NULL;
++-----+-----+----+
+| col | cnt | gp |
++-----+-----+----+
+|     |   3 |  0 |
+| 1   |   3 |  0 |
+| 2   |   3 |  0 |
+| 3   |   3 |  0 |
+|     |   3 |  0 |
++-----+-----+----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c col,
+       count(*) cnt,
+       grouping(c) gp
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING grouping(c) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long col,
+       count(*) cnt,
+       grouping(c_long) gp
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING grouping(c_long) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c_long col,
+       count(*) cnt,
+       grouping(c_long) gp
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING grouping(c_long) IS NOT NULL;
++-----+-----+----+
+| col | cnt | gp |
++-----+-----+----+
+|   0 |   5 |  0 |
+|   1 |   5 |  0 |
+|   2 |   5 |  0 |
++-----+-----+----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----------------------------------------------------+
+| col                                                 |
++-----------------------------------------------------+
+| [null, , 1, 2, 3, null, , 1, 2, 3, null, , 1, 2, 3] |
++-----------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----------------------------------------------+
+| col                                           |
++-----------------------------------------------+
+| [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2] |
++-----------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++--------------------+
+| col                |
++--------------------+
+| [, , ]             |
+| [1, 1, 1]          |
+| [2, 2, 2]          |
+| [3, 3, 3]          |
+| [null, null, null] |
++--------------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-------------------+
+| col               |
++-------------------+
+| [null, , 1, 2, 3] |
+| [null, , 1, 2, 3] |
+| [null, , 1, 2, 3] |
++-------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
++-----------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----------------+
+| col             |
++-----------------+
+| [0, 0, 0, 0, 0] |
+| [1, 1, 1, 1, 1] |
+| [2, 2, 2, 2, 2] |
++-----------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING array_agg(c) IS NOT NULL;
++--------------------+
+| col                |
++--------------------+
+| [, , ]             |
+| [1, 1, 1]          |
+| [2, 2, 2]          |
+| [3, 3, 3]          |
+| [null, null, null] |
++--------------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING array_agg(c) IS NOT NULL;
++-------------------+
+| col               |
++-------------------+
+| [null, , 1, 2, 3] |
+| [null, , 1, 2, 3] |
+| [null, , 1, 2, 3] |
++-------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING array_agg(c_long) IS NOT NULL;
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
++-----------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B27_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING array_agg(c_long) IS NOT NULL;
++-----------------+
+| col             |
++-----------------+
+| [0, 0, 0, 0, 0] |
+| [1, 1, 1, 1, 1] |
+| [2, 2, 2, 2, 2] |
++-----------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-------------------+
+| col               |
++-------------------+
+| [null, , 1, 2, 3] |
++-------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
++-----------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++--------+
+| col    |
++--------+
+| [1]    |
+| [2]    |
+| [3]    |
+| []     |
+| [null] |
++--------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-------------------+
+| col               |
++-------------------+
+| [null, , 1, 2, 3] |
+| [null, , 1, 2, 3] |
+| [null, , 1, 2, 3] |
++-------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
++-----------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----+
+| col |
++-----+
+| [0] |
+| [1] |
+| [2] |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING array_agg(DISTINCT c) IS NOT NULL;
++--------+
+| col    |
++--------+
+| [1]    |
+| [2]    |
+| [3]    |
+| []     |
+| [null] |
++--------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING array_agg(DISTINCT c) IS NOT NULL;
++-------------------+
+| col               |
++-------------------+
+| [null, , 1, 2, 3] |
+| [null, , 1, 2, 3] |
+| [null, , 1, 2, 3] |
++-------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING array_agg(DISTINCT c_long) IS NOT NULL;
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
++-----------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B28_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING array_agg(DISTINCT c_long) IS NOT NULL;
++-----+
+| col |
++-----+
+| [0] |
+| [1] |
+| [2] |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING array_concat_agg(c) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING array_concat_agg(c) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING array_concat_agg(c_long) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING array_concat_agg(c_long) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING array_concat_agg(DISTINCT c) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING array_concat_agg(DISTINCT c) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING array_concat_agg(DISTINCT c_long) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING array_concat_agg(DISTINCT c_long) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++----------------------+
+| col                  |
++----------------------+
+| |1|2|3||1|2|3||1|2|3 |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c_long, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-------------------------------+
+| col                           |
++-------------------------------+
+| 0|0|0|0|0|1|1|1|1|1|2|2|2|2|2 |
++-------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-------+
+| col   |
++-------+
+| 1|1|1 |
+| 2|2|2 |
+| 3|3|3 |
+| ||    |
+|       |
++-------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++--------+
+| col    |
++--------+
+| |1|2|3 |
+| |1|2|3 |
+| |1|2|3 |
++--------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c_long, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-------+
+| col   |
++-------+
+| 0|1|2 |
+| 0|1|2 |
+| 0|1|2 |
+| 0|1|2 |
+| 0|1|2 |
++-------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c_long, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----------+
+| col       |
++-----------+
+| 0|0|0|0|0 |
+| 1|1|1|1|1 |
+| 2|2|2|2|2 |
++-----------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING string_agg(c, '|') IS NOT NULL;
++-------+
+| col   |
++-------+
+| 1|1|1 |
+| 2|2|2 |
+| 3|3|3 |
+| ||    |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING string_agg(c, '|') IS NOT NULL;
++--------+
+| col    |
++--------+
+| |1|2|3 |
+| |1|2|3 |
+| |1|2|3 |
++--------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c_long, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING string_agg(c_long, '|') IS NOT NULL;
++-------+
+| col   |
++-------+
+| 0|1|2 |
+| 0|1|2 |
+| 0|1|2 |
+| 0|1|2 |
+| 0|1|2 |
++-------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B31_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(c_long, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING string_agg(c_long, '|') IS NOT NULL;
++-----------+
+| col       |
++-----------+
+| 0|0|0|0|0 |
+| 1|1|1|1|1 |
+| 2|2|2|2|2 |
++-----------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++--------+
+| col    |
++--------+
+| |1|2|3 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c_long, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-------+
+| col   |
++-------+
+| 0|1|2 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-----+
+| col |
++-----+
+|     |
+| 1   |
+| 2   |
+| 3   |
+|     |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++--------+
+| col    |
++--------+
+| |1|2|3 |
+| |1|2|3 |
+| |1|2|3 |
++--------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c_long, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-------+
+| col   |
++-------+
+| 0|1|2 |
+| 0|1|2 |
+| 0|1|2 |
+| 0|1|2 |
+| 0|1|2 |
++-------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c_long, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----+
+| col |
++-----+
+| 0   |
+| 1   |
+| 2   |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING string_agg(DISTINCT c, '|') IS NOT NULL;
++-----+
+| col |
++-----+
+|     |
+| 1   |
+| 2   |
+| 3   |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING string_agg(DISTINCT c, '|') IS NOT NULL;
++--------+
+| col    |
++--------+
+| |1|2|3 |
+| |1|2|3 |
+| |1|2|3 |
++--------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c_long, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING string_agg(DISTINCT c_long, '|') IS NOT NULL;
++-------+
+| col   |
++-------+
+| 0|1|2 |
+| 0|1|2 |
+| 0|1|2 |
+| 0|1|2 |
+| 0|1|2 |
++-------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B32_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT c_long, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING string_agg(DISTINCT c_long, '|') IS NOT NULL;
++-----+
+| col |
++-----+
+| 0   |
+| 1   |
+| 2   |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|     |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING bit_and(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING bit_and(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING bit_and(c_long) IS NOT NULL;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING bit_and(c_long) IS NOT NULL;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   2 |
+|   3 |
+|     |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING bit_or(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   2 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING bit_or(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING bit_or(c_long) IS NOT NULL;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING bit_or(c_long) IS NOT NULL;
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   2 |
+|   3 |
+|     |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long;
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING bit_xor(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   2 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING bit_xor(c) IS NOT NULL;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c
+HAVING bit_xor(c_long) IS NOT NULL;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+GROUP BY c_long
+HAVING bit_xor(c_long) IS NOT NULL;
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   2 |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array['1',
+             '2',
+             '3'] AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++-----------+
+| col       |
++-----------+
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
+| [1, 2, 3] |
++-----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[c,
+             c,
+             '3'] AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array[c,
+            c,
+            '3'] IS NOT NULL;
++-----------------+
+| col             |
++-----------------+
+| [, , 3]         |
+| [, , 3]         |
+| [, , 3]         |
+| [1, 1, 3]       |
+| [1, 1, 3]       |
+| [1, 1, 3]       |
+| [2, 2, 3]       |
+| [2, 2, 3]       |
+| [2, 2, 3]       |
+| [3, 3, 3]       |
+| [3, 3, 3]       |
+| [3, 3, 3]       |
+| [null, null, 3] |
+| [null, null, 3] |
+| [null, null, 3] |
++-----------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[c,
+             cast(c_long AS char),
+             '3'] AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array[c,
+            cast(c_long AS char),
+            '3'] IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [, 0, 3]     |
+| [, 1, 3]     |
+| [, 2, 3]     |
+| [1, 0, 3]    |
+| [1, 1, 3]    |
+| [1, 2, 3]    |
+| [2, 0, 3]    |
+| [2, 1, 3]    |
+| [2, 2, 3]    |
+| [3, 0, 3]    |
+| [3, 1, 3]    |
+| [3, 2, 3]    |
+| [null, 0, 3] |
+| [null, 1, 3] |
+| [null, 2, 3] |
++--------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[cast(c_long AS char),
+             c,
+             '3'] AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array[cast(c_long AS char),
+            c,
+            '3'] IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [0, , 3]     |
+| [0, 1, 3]    |
+| [0, 2, 3]    |
+| [0, 3, 3]    |
+| [0, null, 3] |
+| [1, , 3]     |
+| [1, 1, 3]    |
+| [1, 2, 3]    |
+| [1, 3, 3]    |
+| [1, null, 3] |
+| [2, , 3]     |
+| [2, 1, 3]    |
+| [2, 2, 3]    |
+| [2, 3, 3]    |
+| [2, null, 3] |
++--------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[cast(c_long AS char),
+             cast(c_long AS char),
+             '3'] AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array[cast(c_long AS char),
+            cast(c_long AS char),
+            '3'] IS NOT NULL;
++-----------+
+| col       |
++-----------+
+| [0, 0, 3] |
+| [0, 0, 3] |
+| [0, 0, 3] |
+| [0, 0, 3] |
+| [0, 0, 3] |
+| [1, 1, 3] |
+| [1, 1, 3] |
+| [1, 1, 3] |
+| [1, 1, 3] |
+| [1, 1, 3] |
+| [2, 2, 3] |
+| [2, 2, 3] |
+| [2, 2, 3] |
+| [2, 2, 3] |
+| [2, 2, 3] |
++-----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (array_length(c) IS NULL
+       OR array_length(c) IN (1));
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array_length(c_long) IN (1);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(c, 0) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array_offset(c, 0)<>'ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(c_long, 0) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array_offset(c_long, 0)<>'ABCD';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(c, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array_ordinal(c, 1)<>'ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(c_long, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array_ordinal(c_long, 1)<>'ABCD';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(c, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (array_contains(c, '1') IS NULL
+       OR array_contains(c, '1') IS TRUE
+       OR array_contains(c, '1') IS FALSE);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
+|       |
+|       |
+|       |
++-------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(c_long, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (array_contains(c_long, '1') IS NULL
+       OR array_contains(c_long, '1') IS TRUE
+       OR array_contains(c_long, '1') IS FALSE);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(c, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (array_overlap(c, c) IS NULL
+       OR array_overlap(c, c) IS TRUE
+       OR array_overlap(c, c) IS FALSE);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+|      |
+|      |
+|      |
++------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(c, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (array_overlap(c, c_long) IS NULL
+       OR array_overlap(c, c_long) IS TRUE
+       OR array_overlap(c, c_long) IS FALSE);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(c_long, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (array_overlap(c_long, c) IS NULL
+       OR array_overlap(c_long, c) IS TRUE
+       OR array_overlap(c_long, c) IS FALSE);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(c_long, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (array_overlap(c_long, c_long) IS NULL
+       OR array_overlap(c_long, c_long) IS TRUE
+       OR array_overlap(c_long, c_long) IS FALSE);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(c, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (array_offset_of(c, '1') IS NULL
+       OR array_offset_of(c, '1') IN (0,
+                                      -1));
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(c_long, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array_offset_of(c_long, '1') <>'ABCD';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(c, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (array_ordinal_of(c, '1') IS NULL
+       OR array_ordinal_of(c, '1') IN (1,
+                                       -1));
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(c_long, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array_ordinal_of(c_long, '1') <>'ABCD';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(c, 'Z') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array_contains(array_prepend(c, 'Z'), 'Z') IS TRUE;
++-----------+
+| col       |
++-----------+
+| [, Z]     |
+| [, Z]     |
+| [, Z]     |
+| [1, Z]    |
+| [1, Z]    |
+| [1, Z]    |
+| [2, Z]    |
+| [2, Z]    |
+| [2, Z]    |
+| [3, Z]    |
+| [3, Z]    |
+| [3, Z]    |
+| [null, Z] |
+| [null, Z] |
+| [null, Z] |
++-----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(c_long, 'Z') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array_contains(array_prepend(c_long, 'Z'), 'Z') IS TRUE;
++--------+
+| col    |
++--------+
+| [0, Z] |
+| [0, Z] |
+| [0, Z] |
+| [0, Z] |
+| [0, Z] |
+| [1, Z] |
+| [1, Z] |
+| [1, Z] |
+| [1, Z] |
+| [1, Z] |
+| [2, Z] |
+| [2, Z] |
+| [2, Z] |
+| [2, Z] |
+| [2, Z] |
++--------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append('Z', c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array_contains(array_append('Z', c), 'Z') IS TRUE;
++-----------+
+| col       |
++-----------+
+| [Z, 1]    |
+| [Z, 1]    |
+| [Z, 1]    |
+| [Z, 2]    |
+| [Z, 2]    |
+| [Z, 2]    |
+| [Z, 3]    |
+| [Z, 3]    |
+| [Z, 3]    |
+| [Z, ]     |
+| [Z, ]     |
+| [Z, ]     |
+| [Z, null] |
+| [Z, null] |
+| [Z, null] |
++-----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append('Z', c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array_contains(array_append('Z', c_long), 'Z') IS TRUE;
++--------+
+| col    |
++--------+
+| [Z, 0] |
+| [Z, 0] |
+| [Z, 0] |
+| [Z, 0] |
+| [Z, 0] |
+| [Z, 1] |
+| [Z, 1] |
+| [Z, 1] |
+| [Z, 1] |
+| [Z, 1] |
+| [Z, 2] |
+| [Z, 2] |
+| [Z, 2] |
+| [Z, 2] |
+| [Z, 2] |
++--------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(c, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (array_concat(c, c) IS NULL
+       OR array_concat(c, c) IS NOT NULL);
++--------+
+| col    |
++--------+
+| [, ]   |
+| [, ]   |
+| [, ]   |
+| [1, 1] |
+| [1, 1] |
+| [1, 1] |
+| [2, 2] |
+| [2, 2] |
+| [2, 2] |
+| [3, 3] |
+| [3, 3] |
+| [3, 3] |
+|        |
+|        |
+|        |
++--------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(c, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (array_concat(c, c_long) IS NULL
+       OR array_concat(c, c_long) IS NOT NULL);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(c_long, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (array_concat(c_long, c) IS NULL
+       OR array_concat(c_long, c) IS NOT NULL);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(c_long, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (array_concat(c_long, c_long) IS NULL
+       OR array_concat(c_long, c_long) IS NOT NULL);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(c, 0, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (array_slice(c, 0, 1) IS NULL
+       OR array_slice(c, 0, 1) IS NOT NULL);
++-----+
+| col |
++-----+
+| [1] |
+| [1] |
+| [1] |
+| [2] |
+| [2] |
+| [2] |
+| [3] |
+| [3] |
+| [3] |
+| []  |
+| []  |
+| []  |
+|     |
+|     |
+|     |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(c_long, 0, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array_slice(c_long, 0, 1)<>'ABCD';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(c, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array_to_string(c, '|') IN ('',
+                                  '1',
+                                  '2',
+                                  '3');
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(c_long, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array_to_string(c_long, '|')<>'ABCD';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(c, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (string_to_array(c, '|') IS NULL
+       OR string_to_array(c, '|') IS NOT NULL);
++-----+
+| col |
++-----+
+| [1] |
+| [1] |
+| [1] |
+| [2] |
+| [2] |
+| [2] |
+| [3] |
+| [3] |
+| [3] |
+| []  |
+| []  |
+| []  |
+|     |
+|     |
+|     |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(c_long, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (string_to_array(c_long, '|') IS NULL
+       OR string_to_array(c_long, '|') IS NOT NULL);
++-----+
+| col |
++-----+
+| [0] |
+| [0] |
+| [0] |
+| [0] |
+| [0] |
+| [1] |
+| [1] |
+| [1] |
+| [1] |
+| [1] |
+| [2] |
+| [2] |
+| [2] |
+| [2] |
+| [2] |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array_to_mv(c) IN ('',
+                         '1',
+                         '2',
+                         '3');
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND array_to_mv(c_long)<>'ABCD';
++-----+
+| col |
++-----+
++-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(c,array['1', '2', '3']) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_filter_only(c,array['1', '2', '3']) IN ('',
+                                                 '1',
+                                                 '2',
+                                                 '3');
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(c, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_filter_only(c, c) IN ('',
+                               '1',
+                               '2',
+                               '3');
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(c, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_filter_only(c, c_long) IN ('',
+                                    '1',
+                                    '2',
+                                    '3');
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(c_long, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_filter_only(c_long, c) IN ('',
+                                    '1',
+                                    '2',
+                                    '3');
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(c_long, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_filter_only(c_long, c_long) IN ('',
+                                         '1',
+                                         '2',
+                                         '3');
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(c,array['1', '2', '3']) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_filter_none(c,array['1', '2', '3']) IN ('',
+                                                 '1',
+                                                 '2',
+                                                 '3');
++-----+
+| col |
++-----+
++-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(c, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_filter_none(c, c) IN ('',
+                               '1',
+                               '2',
+                               '3');
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(c, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_filter_none(c, c_long) IN ('',
+                                    '1',
+                                    '2',
+                                    '3');
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(c_long, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_filter_none(c_long, c) IN ('',
+                                    '1',
+                                    '2',
+                                    '3');
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(c_long, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_filter_none(c_long, c_long) IN ('',
+                                         '1',
+                                         '2',
+                                         '3');
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (mv_length(c) IS NULL
+       OR mv_length(c) IN (1));
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_length(c_long) IN (1);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(c, 0) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_offset(c, 0)<>'ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(c_long, 0) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_offset(c_long, 0)<>'ABCD';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(c, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_ordinal(c, 1)<>'ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(c_long, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_ordinal(c_long, 1)<>'ABCD';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(c, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (mv_contains(c, '1') IS NULL
+       OR mv_contains(c, '1') IS TRUE
+       OR mv_contains(c, '1') IS FALSE);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
++-------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(c_long, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (mv_contains(c_long, '1') IS NULL
+       OR mv_contains(c_long, '1') IS TRUE
+       OR mv_contains(c_long, '1') IS FALSE);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(c, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (mv_overlap(c, c) IS NULL
+       OR mv_overlap(c, c) IS TRUE
+       OR mv_overlap(c, c) IS FALSE);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
++-------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(c, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (mv_overlap(c, c_long) IS NULL
+       OR mv_overlap(c, c_long) IS TRUE
+       OR mv_overlap(c, c_long) IS FALSE);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
++-------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(c_long, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (mv_overlap(c_long, c) IS NULL
+       OR mv_overlap(c_long, c) IS TRUE
+       OR mv_overlap(c_long, c) IS FALSE);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(c_long, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (mv_overlap(c_long, c_long) IS NULL
+       OR mv_overlap(c_long, c_long) IS TRUE
+       OR mv_overlap(c_long, c_long) IS FALSE);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(c, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (mv_offset_of(c, '1') IS NULL
+       OR mv_offset_of(c, '1') IN (0,
+                                   -1));
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(c_long, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_offset_of(c_long, '1') <>'ABCD';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(c, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (mv_ordinal_of(c, '1') IS NULL
+       OR mv_ordinal_of(c, '1') IN (1,
+                                    -1));
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(c_long, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_ordinal_of(c_long, '1') <>'ABCD';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend(c, 'Z') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_contains(mv_prepend(c, 'Z'), 'Z') IS TRUE;
++------------+
+| col        |
++------------+
+| ["","Z"]   |
+| ["","Z"]   |
+| ["","Z"]   |
+| ["1","Z"]  |
+| ["1","Z"]  |
+| ["1","Z"]  |
+| ["2","Z"]  |
+| ["2","Z"]  |
+| ["2","Z"]  |
+| ["3","Z"]  |
+| ["3","Z"]  |
+| ["3","Z"]  |
+| [null,"Z"] |
+| [null,"Z"] |
+| [null,"Z"] |
++------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend(c_long, 'Z') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_contains(mv_prepend(c_long, 'Z'), 'Z') IS TRUE;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append('Z', c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_contains(mv_append('Z', c), 'Z') IS TRUE;
++------------+
+| col        |
++------------+
+| ["Z",""]   |
+| ["Z",""]   |
+| ["Z",""]   |
+| ["Z","1"]  |
+| ["Z","1"]  |
+| ["Z","1"]  |
+| ["Z","2"]  |
+| ["Z","2"]  |
+| ["Z","2"]  |
+| ["Z","3"]  |
+| ["Z","3"]  |
+| ["Z","3"]  |
+| ["Z",null] |
+| ["Z",null] |
+| ["Z",null] |
++------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append('Z', c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_contains(mv_append('Z', c_long), 'Z') IS TRUE;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(c, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (mv_concat(c, c) IS NULL
+       OR mv_concat(c, c) IS NOT NULL);
++-----------+
+| col       |
++-----------+
+| ["",""]   |
+| ["",""]   |
+| ["",""]   |
+| ["1","1"] |
+| ["1","1"] |
+| ["1","1"] |
+| ["2","2"] |
+| ["2","2"] |
+| ["2","2"] |
+| ["3","3"] |
+| ["3","3"] |
+| ["3","3"] |
+|           |
+|           |
+|           |
++-----------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(c, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (mv_concat(c, c_long) IS NULL
+       OR mv_concat(c, c_long) IS NOT NULL);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(c_long, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (mv_concat(c_long, c) IS NULL
+       OR mv_concat(c_long, c) IS NOT NULL);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(c_long, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (mv_concat(c_long, c_long) IS NULL
+       OR mv_concat(c_long, c_long) IS NOT NULL);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(c, 0, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (mv_slice(c, 0, 1) IS NULL
+       OR mv_slice(c, 0, 1) IS NOT NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
+|     |
+|     |
+|     |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(c_long, 0, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_slice(c_long, 0, 1)<>'ABCD';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(c, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_to_string(c, '|') IN ('',
+                               '1',
+                               '2',
+                               '3');
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(c_long, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mv_to_string(c_long, '|')<>'ABCD';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(c, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (string_to_mv(c, '|') IS NULL
+       OR string_to_mv(c, '|') IS NOT NULL);
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
+|     |
+|     |
+|     |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(c_long, '|') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (string_to_mv(c_long, '|') IS NULL
+       OR string_to_mv(c_long, '|') IS NOT NULL);
++-----+
+| col |
++-----+
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c, '$.') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND json_keys(c, '$.') IS NULL;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c_long, '$.') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND json_keys(c_long, '$.') IS NULL;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND json_object(KEY 'k' value c) IS NOT NULL;
++------------+
+| col        |
++------------+
+| {"k":""}   |
+| {"k":""}   |
+| {"k":""}   |
+| {"k":"1"}  |
+| {"k":"1"}  |
+| {"k":"1"}  |
+| {"k":"2"}  |
+| {"k":"2"}  |
+| {"k":"2"}  |
+| {"k":"3"}  |
+| {"k":"3"}  |
+| {"k":"3"}  |
+| {"k":null} |
+| {"k":null} |
+| {"k":null} |
++------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND json_object(KEY 'k' value c_long) IS NOT NULL;
++---------+
+| col     |
++---------+
+| {"k":0} |
+| {"k":0} |
+| {"k":0} |
+| {"k":0} |
+| {"k":0} |
+| {"k":1} |
+| {"k":1} |
+| {"k":1} |
+| {"k":1} |
+| {"k":1} |
+| {"k":2} |
+| {"k":2} |
+| {"k":2} |
+| {"k":2} |
+| {"k":2} |
++---------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND json_paths(c) IS NOT NULL;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND json_paths(c_long) IS NOT NULL;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c, '$.') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (json_query(c, '$.') IS NULL
+       OR json_query(c, '$.') IS NOT NULL);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c_long, '$.') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (json_query(c_long, '$.') IS NULL
+       OR json_query(c_long, '$.') IS NOT NULL);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c, '$.') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c_long, '$.') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (json_value(c_long, '$.') IS NULL
+       OR json_value(c_long, '$.') IS NOT NULL);
++-----+
+| col |
++-----+
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (parse_json(c) IS NULL
+       OR parse_json(c) IS NOT NULL);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(cast(c_long AS char)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (parse_json(cast(c_long AS char)) IS NULL
+       OR parse_json(cast(c_long AS char)) IS NOT NULL);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (try_parse_json(c) IS NULL
+       OR try_parse_json(c) IS NOT NULL);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(cast(c_long AS char)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (try_parse_json(cast(c_long AS char)) IS NULL
+       OR try_parse_json(cast(c_long AS char)) IS NOT NULL);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (to_json_string(c) IS NULL
+       OR to_json_string(c) IS NOT NULL);
++-----+
+| col |
++-----+
+| ""  |
+| ""  |
+| ""  |
+| "1" |
+| "1" |
+| "1" |
+| "2" |
+| "2" |
+| "2" |
+| "3" |
+| "3" |
+| "3" |
+|     |
+|     |
+|     |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (to_json_string(c_long) IS NULL
+       OR to_json_string(c_long) IS NOT NULL);
++-----+
+| col |
++-----+
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 359 Positive tests: 281 Negative tests: 78
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql_scalar_funcs.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql_scalar_funcs.iq
new file mode 100644
index 000000000000..fb41790c5b6c
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaUnnest_mv_sql_scalar_funcs.iq
@@ -0,0 +1,7220 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaUnnest/mv&numMergeBuffers=3
+!set outputformat mysql
+SELECT *
+FROM test_unnest;
++-------------------------+-------+--------+---------+----------+------------------------------------------------+------------------------+--------------------------------------+----------------------------------+--------------------------------------+----------------------------------+-----------------------------+
+| __time                  | c_str | c_long | c_float | c_double | c_mv_complex                                   | c_mv_num               | c_mv_complex_with_null_and_empty_val | c_mv_num_with_null_and_empty_val | c_mv_complex_with_null_and_empty_row | c_mv_num_with_null_and_empty_row | c_mv_all_null_and_empty_val |
++-------------------------+-------+--------+---------+----------+------------------------------------------------+------------------------+--------------------------------------+----------------------------------+--------------------------------------+----------------------------------+-----------------------------+
+| 2022-01-01 00:00:00.000 |       |      1 |     0.1 |      0.1 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 | str2  |      2 |     0.2 |      0.2 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 | str3  |      3 |     0.3 |      0.3 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 | str4  |      4 |     0.4 |      0.4 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            | [null,"",null,"",null]      |
+| 2022-01-01 00:00:00.000 |       |      0 |     0.0 |      0.0 | ["my_null","my_empty","1","[2]","[3, [4, 5]]"] | ["-1","0","1","2","3"] | [null,"","1","[2]","[3, [4, 5]]"]    | [null,"","1","2","3"]            |                                      |                                  | [null,"",null,"",null]      |
++-------------------------+-------+--------+---------+----------+------------------------------------------------+------------------------+--------------------------------------+----------------------------------+--------------------------------------+----------------------------------+-----------------------------+
+(5 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT pi+pi AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND pi<>0;
++-------------------+
+| col               |
++-------------------+
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
+| 6.283185307179586 |
++-------------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT pi AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND pi<>0;
++-------------------+
+| col               |
++-------------------+
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
++-------------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(c)+abs(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (abs(c)+abs(c)) IN (0,
+                          2,
+                          4,
+                          6);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+| 6.0 |
+| 6.0 |
+| 6.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(c+c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND abs(c+c) IN (0,
+                   2,
+                   4,
+                   6);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+| 6.0 |
+| 6.0 |
+| 6.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(c)+abs(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (abs(c)+abs(c_long)) IN (0,
+                               1,
+                               2,
+                               3,
+                               4,
+                               5);
++-----+
+| col |
++-----+
+| 1.0 |
+| 2.0 |
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+| 4.0 |
+| 5.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(c+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (abs(c)+abs(c_long)) IN (0,
+                               1,
+                               2,
+                               3,
+                               4,
+                               5);
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|   2 |
+|   3 |
+|   3 |
+|   3 |
+|   4 |
+|   4 |
+|   5 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(c)+ceil(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (ceil(c)+ceil(c)) IN (0,
+                            2,
+                            4,
+                            6);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+| 6.0 |
+| 6.0 |
+| 6.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B3_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(c+c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND ceil(c+c) IN (0,
+                    2,
+                    4,
+                    6);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+| 6.0 |
+| 6.0 |
+| 6.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(c)+ceil(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (ceil(c)+ceil(c_long)) IN (0,
+                                 1,
+                                 2,
+                                 3,
+                                 4,
+                                 5);
++-----+
+| col |
++-----+
+| 1.0 |
+| 2.0 |
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+| 4.0 |
+| 5.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B3_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(c+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND ceil(c+c_long) IN (0,
+                         1,
+                         2,
+                         3,
+                         4,
+                         5);
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|   2 |
+|   3 |
+|   3 |
+|   3 |
+|   4 |
+|   4 |
+|   5 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(c)+exp(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (exp(c)+exp(c))<>0;
++--------------------+
+| col                |
++--------------------+
+|   14.7781121978613 |
+|   14.7781121978613 |
+|   14.7781121978613 |
+| 40.171073846375336 |
+| 40.171073846375336 |
+| 40.171073846375336 |
+|   5.43656365691809 |
+|   5.43656365691809 |
+|   5.43656365691809 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B4_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(c+c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND exp(c+c)<>0;
++--------------------+
+| col                |
++--------------------+
+|  403.4287934927351 |
+|  403.4287934927351 |
+|  403.4287934927351 |
+| 54.598150033144236 |
+| 54.598150033144236 |
+| 54.598150033144236 |
+|   7.38905609893065 |
+|   7.38905609893065 |
+|   7.38905609893065 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(c)+exp(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (exp(c)+exp(c_long))<>0;
++--------------------+
+| col                |
++--------------------+
+| 10.107337927389695 |
+| 10.107337927389695 |
+|   14.7781121978613 |
+| 21.085536923187668 |
+| 22.803818751646713 |
+|  27.47459302211832 |
+|  3.718281828459045 |
+|   5.43656365691809 |
+|   8.38905609893065 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B4_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(c+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND exp(c+c_long)<>0;
++--------------------+
+| col                |
++--------------------+
+|  148.4131591025766 |
+|  2.718281828459045 |
+| 20.085536923187668 |
+| 20.085536923187668 |
+| 20.085536923187668 |
+| 54.598150033144236 |
+| 54.598150033144236 |
+|   7.38905609893065 |
+|   7.38905609893065 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(c)+floor(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (floor(c)+floor(c)) IN (0,
+                              2,
+                              4,
+                              6);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+| 6.0 |
+| 6.0 |
+| 6.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B5_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(c+c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND floor(c+c) IN (0,
+                     2,
+                     4,
+                     6);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+| 6.0 |
+| 6.0 |
+| 6.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(c)+floor(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (floor(c)+floor(c_long)) IN (0,
+                                   1,
+                                   2,
+                                   3,
+                                   4,
+                                   5);
++-----+
+| col |
++-----+
+| 1.0 |
+| 2.0 |
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+| 4.0 |
+| 5.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B5_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(c+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND floor(c+c_long) IN (0,
+                          1,
+                          2,
+                          3,
+                          4,
+                          5);
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|   2 |
+|   3 |
+|   3 |
+|   3 |
+|   4 |
+|   4 |
+|   5 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(c)+ln(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (ln(c)+ln(c))<>99999;
++--------------------+
+| col                |
++--------------------+
+|                0.0 |
+|                0.0 |
+|                0.0 |
+| 1.3862943611198906 |
+| 1.3862943611198906 |
+| 1.3862943611198906 |
+| 2.1972245773362196 |
+| 2.1972245773362196 |
+| 2.1972245773362196 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B6_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(c+c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND ln(c+c)<>99999;
++--------------------+
+| col                |
++--------------------+
+| 0.6931471805599453 |
+| 0.6931471805599453 |
+| 0.6931471805599453 |
+| 1.3862943611198906 |
+| 1.3862943611198906 |
+| 1.3862943611198906 |
+|  1.791759469228055 |
+|  1.791759469228055 |
+|  1.791759469228055 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(c)+ln(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (ln(c)+ln(c_long))<>99999;
++--------------------+
+| col                |
++--------------------+
+|          -Infinity |
+|          -Infinity |
+|          -Infinity |
+|                0.0 |
+| 0.6931471805599453 |
+| 0.6931471805599453 |
+| 1.0986122886681098 |
+| 1.3862943611198906 |
+|  1.791759469228055 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B6_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(c+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND ln(c+c_long)<>99999;
++--------------------+
+| col                |
++--------------------+
+|                0.0 |
+| 0.6931471805599453 |
+| 0.6931471805599453 |
+| 1.0986122886681098 |
+| 1.0986122886681098 |
+| 1.0986122886681098 |
+| 1.3862943611198906 |
+| 1.3862943611198906 |
+| 1.6094379124341003 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(c)+log10(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (log10(c)+log10(c))<>99999;
++--------------------+
+| col                |
++--------------------+
+|                0.0 |
+|                0.0 |
+|                0.0 |
+| 0.6020599913279624 |
+| 0.6020599913279624 |
+| 0.6020599913279624 |
+| 0.9542425094393249 |
+| 0.9542425094393249 |
+| 0.9542425094393249 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B7_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(c+c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND log10(c+c)<>99999;
++--------------------+
+| col                |
++--------------------+
+| 0.3010299956639812 |
+| 0.3010299956639812 |
+| 0.3010299956639812 |
+| 0.6020599913279624 |
+| 0.6020599913279624 |
+| 0.6020599913279624 |
+| 0.7781512503836436 |
+| 0.7781512503836436 |
+| 0.7781512503836436 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(c)+log10(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (log10(c)+log10(c_long))<>99999;
++---------------------+
+| col                 |
++---------------------+
+|           -Infinity |
+|           -Infinity |
+|           -Infinity |
+|                 0.0 |
+|  0.3010299956639812 |
+|  0.3010299956639812 |
+| 0.47712125471966244 |
+|  0.6020599913279624 |
+|  0.7781512503836436 |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B7_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(c+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND log10(c+c_long)<>99999;
++---------------------+
+| col                 |
++---------------------+
+|                 0.0 |
+|  0.3010299956639812 |
+|  0.3010299956639812 |
+| 0.47712125471966244 |
+| 0.47712125471966244 |
+| 0.47712125471966244 |
+|  0.6020599913279624 |
+|  0.6020599913279624 |
+|  0.6989700043360189 |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(c, 1)+power(c, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (power(c, 1)+power(c, 1)) IN (0,
+                                    2,
+                                    4,
+                                    6);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+| 6.0 |
+| 6.0 |
+| 6.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B8_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(c+c, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND power(c+c, 1) IN (0,
+                        2,
+                        4,
+                        6);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+| 6.0 |
+| 6.0 |
+| 6.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(c, 1)+power(c_long, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (power(c, 1)+power(c_long, 1)) IN (0,
+                                         1,
+                                         2,
+                                         3,
+                                         4,
+                                         5);
++-----+
+| col |
++-----+
+| 1.0 |
+| 2.0 |
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+| 4.0 |
+| 5.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B8_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(c+c_long, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND power(c+c_long, 1) IN (0,
+                             1,
+                             2,
+                             3,
+                             4,
+                             5);
++-----+
+| col |
++-----+
+| 1.0 |
+| 2.0 |
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+| 4.0 |
+| 5.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(c)+sqrt(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (sqrt(c)+sqrt(c))<>99999;
++--------------------+
+| col                |
++--------------------+
+|                2.0 |
+|                2.0 |
+|                2.0 |
+| 2.8284271247461903 |
+| 2.8284271247461903 |
+| 2.8284271247461903 |
+| 3.4641016151377544 |
+| 3.4641016151377544 |
+| 3.4641016151377544 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B9_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(c+c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND sqrt(c+c)<>99999;
++--------------------+
+| col                |
++--------------------+
+| 1.4142135623730951 |
+| 1.4142135623730951 |
+| 1.4142135623730951 |
+|                2.0 |
+|                2.0 |
+|                2.0 |
+|  2.449489742783178 |
+|  2.449489742783178 |
+|  2.449489742783178 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(c)+sqrt(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (sqrt(c)+sqrt(c_long))<>99999;
++--------------------+
+| col                |
++--------------------+
+|                1.0 |
+| 1.4142135623730951 |
+| 1.7320508075688772 |
+|                2.0 |
+|  2.414213562373095 |
+|  2.414213562373095 |
+|  2.732050807568877 |
+| 2.8284271247461903 |
+| 3.1462643699419726 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B9_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(c+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND sqrt(c+c_long)<>99999;
++--------------------+
+| col                |
++--------------------+
+|                1.0 |
+| 1.4142135623730951 |
+| 1.4142135623730951 |
+| 1.7320508075688772 |
+| 1.7320508075688772 |
+| 1.7320508075688772 |
+|                2.0 |
+|                2.0 |
+|   2.23606797749979 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(cast(c AS decimal), 1)+truncate(cast(c AS decimal), 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (truncate(cast(c AS decimal), 1)+truncate(cast(c AS decimal), 1)) IN (0,
+                                                                            2,
+                                                                            4,
+                                                                            6);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+| 6.0 |
+| 6.0 |
+| 6.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B10_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(cast(c AS decimal)+cast(c AS decimal), 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND truncate(cast(c AS decimal)+cast(c AS decimal), 1) IN (0,
+                                                             2,
+                                                             4,
+                                                             6);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+| 6.0 |
+| 6.0 |
+| 6.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(cast(c AS decimal), 1)+truncate(c_long, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (truncate(cast(c AS decimal), 1)+truncate(c_long, 1)) IN (0,
+                                                                1,
+                                                                2,
+                                                                3,
+                                                                4,
+                                                                5);
++-----+
+| col |
++-----+
+| 1.0 |
+| 2.0 |
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+| 4.0 |
+| 5.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B10_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(cast(c AS decimal)+c_long, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND truncate(cast(c AS decimal)+c_long, 1) IN (0,
+                                                 1,
+                                                 2,
+                                                 3,
+                                                 4,
+                                                 5);
++-----+
+| col |
++-----+
+| 1.0 |
+| 2.0 |
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+| 4.0 |
+| 5.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(cast(c AS decimal), 1)+trunc(cast(c AS decimal), 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (trunc(cast(c AS decimal), 1)+trunc(cast(c AS decimal), 1)) IN (0,
+                                                                      2,
+                                                                      4,
+                                                                      6);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+| 6.0 |
+| 6.0 |
+| 6.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B11_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(cast(c AS decimal)+cast(c AS decimal), 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND trunc(cast(c AS decimal)+cast(c AS decimal), 1) IN (0,
+                                                          2,
+                                                          4,
+                                                          6);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+| 6.0 |
+| 6.0 |
+| 6.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(cast(c AS decimal), 1)+trunc(c_long, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (trunc(cast(c AS decimal), 1)+trunc(c_long, 1)) IN (0,
+                                                          1,
+                                                          2,
+                                                          3,
+                                                          4,
+                                                          5);
++-----+
+| col |
++-----+
+| 1.0 |
+| 2.0 |
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+| 4.0 |
+| 5.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B11_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(cast(c AS decimal)+c_long, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND trunc(cast(c AS decimal)+c_long, 1) IN (0,
+                                              1,
+                                              2,
+                                              3,
+                                              4,
+                                              5);
++-----+
+| col |
++-----+
+| 1.0 |
+| 2.0 |
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+| 4.0 |
+| 5.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(cast(c AS decimal), 1)+round(cast(c AS decimal), 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (round(cast(c AS decimal), 1)+round(cast(c AS decimal), 1)) IN (0,
+                                                                      2,
+                                                                      4,
+                                                                      6);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+| 6.0 |
+| 6.0 |
+| 6.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B12_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(cast(c AS decimal)+cast(c AS decimal), 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND round(cast(c AS decimal)+cast(c AS decimal), 1) IN (0,
+                                                          2,
+                                                          4,
+                                                          6);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+| 6.0 |
+| 6.0 |
+| 6.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(cast(c AS decimal), 1)+round(c_long, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (round(cast(c AS decimal), 1)+round(c_long, 1)) IN (0,
+                                                          1,
+                                                          2,
+                                                          3,
+                                                          4,
+                                                          5);
++-----+
+| col |
++-----+
+| 1.0 |
+| 2.0 |
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+| 4.0 |
+| 5.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B12_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(cast(c AS decimal)+c_long, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND round(cast(c AS decimal)+c_long, 1) IN (0,
+                                              1,
+                                              2,
+                                              3,
+                                              4,
+                                              5);
++-----+
+| col |
++-----+
+| 1.0 |
+| 2.0 |
+| 2.0 |
+| 3.0 |
+| 3.0 |
+| 3.0 |
+| 4.0 |
+| 4.0 |
+| 5.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(c, 2)+mod(c, 2) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (mod(c, 2)+mod(c, 2)) IN (0,
+                                2);
++-----+
+| col |
++-----+
+| 0.0 |
+| 0.0 |
+| 0.0 |
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 2.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B13_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(c, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mod(c, c)<>99999;
++-----+
+| col |
++-----+
+| 0.0 |
+| 0.0 |
+| 0.0 |
+| 0.0 |
+| 0.0 |
+| 0.0 |
+| 0.0 |
+| 0.0 |
+| 0.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B13_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(c, 2)+mod(c_long, 2) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (mod(c, 2)+mod(c_long, 2)) IN (0,
+                                     1,
+                                     2);
++-----+
+| col |
++-----+
+| 0.0 |
+| 0.0 |
+| 1.0 |
+| 1.0 |
+| 1.0 |
+| 1.0 |
+| 1.0 |
+| 2.0 |
+| 2.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B13_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(c, c_long+1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND mod(c, c_long+1) IN (0,
+                           1,
+                           2);
++-----+
+| col |
++-----+
+| 0.0 |
+| 0.0 |
+| 0.0 |
+| 0.0 |
+| 0.0 |
+| 1.0 |
+| 1.0 |
+| 1.0 |
+| 2.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(c)+sin(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (sin(c)+sin(c))<>99999;
++--------------------+
+| col                |
++--------------------+
+| 0.2822400161197344 |
+| 0.2822400161197344 |
+| 0.2822400161197344 |
+|  1.682941969615793 |
+|  1.682941969615793 |
+|  1.682941969615793 |
+| 1.8185948536513634 |
+| 1.8185948536513634 |
+| 1.8185948536513634 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B14_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(c+c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND sin(c+c)<>99999;
++----------------------+
+| col                  |
++----------------------+
+| -0.27941549819892586 |
+| -0.27941549819892586 |
+| -0.27941549819892586 |
+|  -0.7568024953079282 |
+|  -0.7568024953079282 |
+|  -0.7568024953079282 |
+|   0.9092974268256817 |
+|   0.9092974268256817 |
+|   0.9092974268256817 |
++----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(c)+sin(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (sin(c)+sin(c_long))<>99999;
++--------------------+
+| col                |
++--------------------+
+| 0.1411200080598672 |
+| 0.8414709848078965 |
+| 0.9092974268256817 |
+| 0.9825909928677637 |
+| 1.0504174348855488 |
+|  1.682941969615793 |
+| 1.7507684116335782 |
+| 1.7507684116335782 |
+| 1.8185948536513634 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B14_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(c+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND sin(c+c_long)<>99999;
++---------------------+
+| col                 |
++---------------------+
+| -0.7568024953079282 |
+| -0.7568024953079282 |
+| -0.9589242746631385 |
+|  0.1411200080598672 |
+|  0.1411200080598672 |
+|  0.1411200080598672 |
+|  0.8414709848078965 |
+|  0.9092974268256817 |
+|  0.9092974268256817 |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(c)+cos(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (cos(c)+cos(c))<>99999;
++---------------------+
+| col                 |
++---------------------+
+| -0.8322936730942848 |
+| -0.8322936730942848 |
+| -0.8322936730942848 |
+| -1.9799849932008908 |
+| -1.9799849932008908 |
+| -1.9799849932008908 |
+|  1.0806046117362795 |
+|  1.0806046117362795 |
+|  1.0806046117362795 |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B15_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(c+c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND cos(c+c)<>99999;
++---------------------+
+| col                 |
++---------------------+
+| -0.4161468365471424 |
+| -0.4161468365471424 |
+| -0.4161468365471424 |
+| -0.6536436208636119 |
+| -0.6536436208636119 |
+| -0.6536436208636119 |
+|   0.960170286650366 |
+|   0.960170286650366 |
+|   0.960170286650366 |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B15_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(c)+cos(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (cos(c)+cos(c_long))<>99999;
++----------------------+
+| col                  |
++----------------------+
+| -0.44969019073230565 |
+|  -0.8322936730942848 |
+|  -1.4061393331475878 |
+| 0.010007503399554585 |
+|  0.12415546932099736 |
+|  0.12415546932099736 |
+|   0.5838531634528576 |
+|   1.0806046117362795 |
+|   1.5403023058681398 |
++----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B15_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(c+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND cos(c+c_long)<>99999;
++---------------------+
+| col                 |
++---------------------+
+| -0.4161468365471424 |
+| -0.4161468365471424 |
+| -0.6536436208636119 |
+| -0.6536436208636119 |
+| -0.9899924966004454 |
+| -0.9899924966004454 |
+| -0.9899924966004454 |
+| 0.28366218546322625 |
+|  0.5403023058681398 |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B16_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(c)+tan(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (tan(c)+tan(c))<>99999;
++---------------------+
+| col                 |
++---------------------+
+| -0.2850930861485556 |
+| -0.2850930861485556 |
+| -0.2850930861485556 |
+|  -4.370079726523038 |
+|  -4.370079726523038 |
+|  -4.370079726523038 |
+|  3.1148154493098046 |
+|  3.1148154493098046 |
+|  3.1148154493098046 |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B16_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(c+c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND tan(c+c)<>99999;
++----------------------+
+| col                  |
++----------------------+
+| -0.29100619138474915 |
+| -0.29100619138474915 |
+| -0.29100619138474915 |
+|   -2.185039863261519 |
+|   -2.185039863261519 |
+|   -2.185039863261519 |
+|   1.1578212823495775 |
+|   1.1578212823495775 |
+|   1.1578212823495775 |
++----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B16_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(c)+tan(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (tan(c)+tan(c_long))<>99999;
++---------------------+
+| col                 |
++---------------------+
+| -0.1425465430742778 |
+| -0.6276321386066166 |
+| -0.6276321386066166 |
+|  -2.185039863261519 |
+| -2.3275864063357967 |
+|  -4.370079726523038 |
+|  1.4148611815806245 |
+|  1.5574077246549023 |
+|  3.1148154493098046 |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B16_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(c+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND tan(c+c_long)<>99999;
++---------------------+
+| col                 |
++---------------------+
+| -0.1425465430742778 |
+| -0.1425465430742778 |
+| -0.1425465430742778 |
+|  -2.185039863261519 |
+|  -2.185039863261519 |
+|  -3.380515006246586 |
+|  1.1578212823495775 |
+|  1.1578212823495775 |
+|  1.5574077246549023 |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(c)+cot(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (cot(c)+cot(c))<>99999;
++---------------------+
+| col                 |
++---------------------+
+| -0.9153151087205715 |
+| -0.9153151087205715 |
+| -0.9153151087205715 |
+| -14.030505102869068 |
+| -14.030505102869068 |
+| -14.030505102869068 |
+|  1.2841852318686615 |
+|  1.2841852318686615 |
+|  1.2841852318686615 |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B17_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(c+c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND cot(c+c)<>99999;
++----------------------+
+| col                  |
++----------------------+
+| -0.45765755436028577 |
+| -0.45765755436028577 |
+| -0.45765755436028577 |
+|   -3.436353004180128 |
+|   -3.436353004180128 |
+|   -3.436353004180128 |
+|   0.8636911544506167 |
+|   0.8636911544506167 |
+|   0.8636911544506167 |
++----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(c)+cot(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (cot(c)+cot(c_long))<>99999;
++---------------------+
+| col                 |
++---------------------+
+| -0.9153151087205715 |
+|  -6.373159935500203 |
+|   -7.47291010579482 |
+|   0.184435061574045 |
+|   0.184435061574045 |
+|  1.2841852318686615 |
+|            Infinity |
+|            Infinity |
+|            Infinity |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B17_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(c+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND cot(c+c_long)<>99999;
++----------------------+
+| col                  |
++----------------------+
+|  -0.2958129155327455 |
+| -0.45765755436028577 |
+| -0.45765755436028577 |
+|   -7.015252551434534 |
+|   -7.015252551434534 |
+|   -7.015252551434534 |
+|   0.6420926159343308 |
+|   0.8636911544506167 |
+|   0.8636911544506167 |
++----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(c)+asin(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (asin(c)+asin(c))<>99999;
++-------------------+
+| col               |
++-------------------+
+| 3.141592653589793 |
+| 3.141592653589793 |
+| 3.141592653589793 |
+|               NaN |
+|               NaN |
+|               NaN |
+|               NaN |
+|               NaN |
+|               NaN |
++-------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B18_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(c+c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND asin(c+c)<>99999;
++-----+
+| col |
++-----+
+| NaN |
+| NaN |
+| NaN |
+| NaN |
+| NaN |
+| NaN |
+| NaN |
+| NaN |
+| NaN |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B18_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(c)+asin(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (asin(c)+asin(c_long))<>99999;
++--------------------+
+| col                |
++--------------------+
+| 1.5707963267948966 |
+|  3.141592653589793 |
+|                NaN |
+|                NaN |
+|                NaN |
+|                NaN |
+|                NaN |
+|                NaN |
+|                NaN |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B18_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(c+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND asin(c+c_long)<>99999;
++--------------------+
+| col                |
++--------------------+
+| 1.5707963267948966 |
+|                NaN |
+|                NaN |
+|                NaN |
+|                NaN |
+|                NaN |
+|                NaN |
+|                NaN |
+|                NaN |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(c)+acos(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (acos(c)+acos(c))<>99999;
++-----+
+| col |
++-----+
+| 0.0 |
+| 0.0 |
+| 0.0 |
+| NaN |
+| NaN |
+| NaN |
+| NaN |
+| NaN |
+| NaN |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B19_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(c+c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND acos(c+c)<>99999;
++-----+
+| col |
++-----+
+| NaN |
+| NaN |
+| NaN |
+| NaN |
+| NaN |
+| NaN |
+| NaN |
+| NaN |
+| NaN |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(c)+acos(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (acos(c)+acos(c_long))<>99999;
++--------------------+
+| col                |
++--------------------+
+|                0.0 |
+| 1.5707963267948966 |
+|                NaN |
+|                NaN |
+|                NaN |
+|                NaN |
+|                NaN |
+|                NaN |
+|                NaN |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B19_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(c+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND acos(c+c_long)<>99999;
++-----+
+| col |
++-----+
+| 0.0 |
+| NaN |
+| NaN |
+| NaN |
+| NaN |
+| NaN |
+| NaN |
+| NaN |
+| NaN |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(c)+atan(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (atan(c)+atan(c))<>99999;
++--------------------+
+| col                |
++--------------------+
+| 1.5707963267948966 |
+| 1.5707963267948966 |
+| 1.5707963267948966 |
+|  2.214297435588181 |
+|  2.214297435588181 |
+|  2.214297435588181 |
+|  2.498091544796509 |
+|  2.498091544796509 |
+|  2.498091544796509 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B20_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(c+c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND atan(c+c)<>99999;
++--------------------+
+| col                |
++--------------------+
+| 1.1071487177940904 |
+| 1.1071487177940904 |
+| 1.1071487177940904 |
+| 1.3258176636680326 |
+| 1.3258176636680326 |
+| 1.3258176636680326 |
+| 1.4056476493802699 |
+| 1.4056476493802699 |
+| 1.4056476493802699 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(c)+atan(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (atan(c)+atan(c_long))<>99999;
++--------------------+
+| col                |
++--------------------+
+| 0.7853981633974483 |
+| 1.1071487177940904 |
+| 1.2490457723982544 |
+| 1.5707963267948966 |
+| 1.8925468811915387 |
+| 1.8925468811915387 |
+| 2.0344439357957027 |
+|  2.214297435588181 |
+|  2.356194490192345 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B20_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(c+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND atan(c+c_long)<>99999;
++--------------------+
+| col                |
++--------------------+
+| 0.7853981633974483 |
+| 1.1071487177940904 |
+| 1.1071487177940904 |
+| 1.2490457723982544 |
+| 1.2490457723982544 |
+| 1.2490457723982544 |
+| 1.3258176636680326 |
+| 1.3258176636680326 |
+|  1.373400766945016 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(c, 1)+atan2(c, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (atan2(c, 1)+atan2(c, 1))<>99999;
++--------------------+
+| col                |
++--------------------+
+| 1.5707963267948966 |
+| 1.5707963267948966 |
+| 1.5707963267948966 |
+|  2.214297435588181 |
+|  2.214297435588181 |
+|  2.214297435588181 |
+|  2.498091544796509 |
+|  2.498091544796509 |
+|  2.498091544796509 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B21_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(c, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND atan2(c, c)<>99999;
++--------------------+
+| col                |
++--------------------+
+| 0.7853981633974483 |
+| 0.7853981633974483 |
+| 0.7853981633974483 |
+| 0.7853981633974483 |
+| 0.7853981633974483 |
+| 0.7853981633974483 |
+| 0.7853981633974483 |
+| 0.7853981633974483 |
+| 0.7853981633974483 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(c, 1)+atan2(c_long, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (atan2(c, 1)+atan2(c_long, 1))<>99999;
++--------------------+
+| col                |
++--------------------+
+| 0.7853981633974483 |
+| 1.1071487177940904 |
+| 1.2490457723982544 |
+| 1.5707963267948966 |
+| 1.8925468811915387 |
+| 1.8925468811915387 |
+| 2.0344439357957027 |
+|  2.214297435588181 |
+|  2.356194490192345 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B21_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(c, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND atan2(c, c_long)<>99999;
++--------------------+
+| col                |
++--------------------+
+| 0.4636476090008061 |
+| 0.7853981633974483 |
+| 0.7853981633974483 |
+|  0.982793723247329 |
+| 1.1071487177940904 |
+| 1.2490457723982544 |
+| 1.5707963267948966 |
+| 1.5707963267948966 |
+| 1.5707963267948966 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(c)+degrees(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (degrees(c)+degrees(c))<>99999;
++--------------------+
+| col                |
++--------------------+
+| 114.59155902616465 |
+| 114.59155902616465 |
+| 114.59155902616465 |
+|  229.1831180523293 |
+|  229.1831180523293 |
+|  229.1831180523293 |
+| 343.77467707849394 |
+| 343.77467707849394 |
+| 343.77467707849394 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B22_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(c+c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND degrees(c+c)<>99999;
++--------------------+
+| col                |
++--------------------+
+| 114.59155902616465 |
+| 114.59155902616465 |
+| 114.59155902616465 |
+|  229.1831180523293 |
+|  229.1831180523293 |
+|  229.1831180523293 |
+| 343.77467707849394 |
+| 343.77467707849394 |
+| 343.77467707849394 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B22_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(c)+degrees(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (degrees(c)+degrees(c_long))<>99999;
++--------------------+
+| col                |
++--------------------+
+| 114.59155902616465 |
+| 114.59155902616465 |
+| 171.88733853924697 |
+| 171.88733853924697 |
+| 171.88733853924697 |
+|  229.1831180523293 |
+|  229.1831180523293 |
+|  286.4788975654116 |
+|  57.29577951308232 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B22_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(c+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND degrees(c+c_long)<>99999;
++--------------------+
+| col                |
++--------------------+
+| 114.59155902616465 |
+| 114.59155902616465 |
+| 171.88733853924697 |
+| 171.88733853924697 |
+| 171.88733853924697 |
+|  229.1831180523293 |
+|  229.1831180523293 |
+|  286.4788975654116 |
+|  57.29577951308232 |
++--------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(c)+radians(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (radians(c)+radians(c))<>99999;
++---------------------+
+| col                 |
++---------------------+
+| 0.03490658503988659 |
+| 0.03490658503988659 |
+| 0.03490658503988659 |
+| 0.06981317007977318 |
+| 0.06981317007977318 |
+| 0.06981317007977318 |
+| 0.10471975511965978 |
+| 0.10471975511965978 |
+| 0.10471975511965978 |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B23_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(c+c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND radians(c+c)<>99999;
++---------------------+
+| col                 |
++---------------------+
+| 0.03490658503988659 |
+| 0.03490658503988659 |
+| 0.03490658503988659 |
+| 0.06981317007977318 |
+| 0.06981317007977318 |
+| 0.06981317007977318 |
+| 0.10471975511965978 |
+| 0.10471975511965978 |
+| 0.10471975511965978 |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(c)+radians(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (radians(c)+radians(c_long))<>99999;
++----------------------+
+| col                  |
++----------------------+
+| 0.017453292519943295 |
+|  0.03490658503988659 |
+|  0.03490658503988659 |
+|  0.05235987755982989 |
+|  0.05235987755982989 |
+|  0.05235987755982989 |
+|  0.06981317007977318 |
+|  0.06981317007977318 |
+|  0.08726646259971649 |
++----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B23_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(c+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND radians(c+c_long)<>99999;
++----------------------+
+| col                  |
++----------------------+
+| 0.017453292519943295 |
+|  0.03490658503988659 |
+|  0.03490658503988659 |
+|  0.05235987755982989 |
+|  0.05235987755982989 |
+|  0.05235987755982989 |
+|  0.06981317007977318 |
+|  0.06981317007977318 |
+|  0.08726646259971647 |
++----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(cast(c AS int), 1)+bitwise_and(cast(c AS int), 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (bitwise_and(cast(c AS int), 1)+bitwise_and(cast(c AS int), 1)) IN (0,
+                                                                          2);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B24_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(cast(c AS int), cast(c AS int)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND bitwise_and(cast(c AS int), cast(c AS int)) IN (0,
+                                                      1,
+                                                      2,
+                                                      3);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(cast(c AS int), 1)+bitwise_and(c_long, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (bitwise_and(cast(c AS int), 1)+bitwise_and(c_long, 1)) IN (0,
+                                                                  1,
+                                                                  2);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B24_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(cast(c AS int), c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND bitwise_and(cast(c AS int), c_long) IN (0,
+                                              1,
+                                              2);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(cast(c AS int))+bitwise_complement(cast(c AS int)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (bitwise_complement(cast(c AS int))+bitwise_complement(cast(c AS int))) IN (-2,
+                                                                                  -4,
+                                                                                  -6,
+                                                                                  -8);
++-----+
+| col |
++-----+
+|  -4 |
+|  -4 |
+|  -4 |
+|  -6 |
+|  -6 |
+|  -6 |
+|  -8 |
+|  -8 |
+|  -8 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B25_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(cast(c AS int)+cast(c AS int)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND bitwise_complement(cast(c AS int)+cast(c AS int)) IN (-1,
+                                                            -3,
+                                                            -5,
+                                                            -7);
++-----+
+| col |
++-----+
+|  -3 |
+|  -3 |
+|  -3 |
+|  -5 |
+|  -5 |
+|  -5 |
+|  -7 |
+|  -7 |
+|  -7 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B25_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(cast(c AS int))+bitwise_complement(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (bitwise_complement(cast(c AS int))+bitwise_complement(c_long)) IN (-2,
+                                                                          -3,
+                                                                          -4,
+                                                                          -5,
+                                                                          -6,
+                                                                          -7);
++-----+
+| col |
++-----+
+|  -3 |
+|  -4 |
+|  -4 |
+|  -5 |
+|  -5 |
+|  -5 |
+|  -6 |
+|  -6 |
+|  -7 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B25_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(cast(c AS int)+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND bitwise_complement(cast(c AS int)+c_long) IN (-1,
+                                                    -2,
+                                                    -3,
+                                                    -4,
+                                                    -5,
+                                                    -6);
++-----+
+| col |
++-----+
+|  -2 |
+|  -3 |
+|  -3 |
+|  -4 |
+|  -4 |
+|  -4 |
+|  -5 |
+|  -5 |
+|  -6 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(cast(c AS DOUBLE))+bitwise_convert_double_to_long_bits(cast(c AS DOUBLE)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (bitwise_convert_double_to_long_bits(cast(c AS DOUBLE))+bitwise_convert_double_to_long_bits(cast(c AS DOUBLE)))<>99999;
++----------------------+
+| col                  |
++----------------------+
+| -9218868437227405312 |
+| -9218868437227405312 |
+| -9218868437227405312 |
+| -9223372036854775808 |
+| -9223372036854775808 |
+| -9223372036854775808 |
+|  9214364837600034816 |
+|  9214364837600034816 |
+|  9214364837600034816 |
++----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B26_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(cast(c AS DOUBLE)+cast(c AS DOUBLE)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND bitwise_convert_double_to_long_bits(cast(c AS DOUBLE)+cast(c AS DOUBLE))<>99999;
++---------------------+
+| col                 |
++---------------------+
+| 4611686018427387904 |
+| 4611686018427387904 |
+| 4611686018427387904 |
+| 4616189618054758400 |
+| 4616189618054758400 |
+| 4616189618054758400 |
+| 4618441417868443648 |
+| 4618441417868443648 |
+| 4618441417868443648 |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(cast(c AS DOUBLE))+bitwise_convert_double_to_long_bits(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (bitwise_convert_double_to_long_bits(cast(c AS DOUBLE))+bitwise_convert_double_to_long_bits(c_long))<>99999;
++----------------------+
+| col                  |
++----------------------+
+| -9221120237041090560 |
+| -9223372036854775808 |
+|  4607182418800017408 |
+|  4611686018427387904 |
+|  4613937818241073152 |
+|  9214364837600034816 |
+|  9218868437227405312 |
+|  9218868437227405312 |
+|  9221120237041090560 |
++----------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B26_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(cast(c AS DOUBLE)+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND bitwise_convert_double_to_long_bits(cast(c AS DOUBLE)+c_long)<>99999;
++---------------------+
+| col                 |
++---------------------+
+| 4607182418800017408 |
+| 4611686018427387904 |
+| 4611686018427387904 |
+| 4613937818241073152 |
+| 4613937818241073152 |
+| 4613937818241073152 |
+| 4616189618054758400 |
+| 4616189618054758400 |
+| 4617315517961601024 |
++---------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT bitwise_convert_long_bits_to_double(cast(c AS int))+bitwise_convert_long_bits_to_double(cast(c AS int)) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND (bitwise_convert_long_bits_to_double(cast(c AS int))+bitwise_convert_long_bits_to_double(cast(c AS int)))<>99999);
++-----+
+| cnt |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B27_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT bitwise_convert_long_bits_to_double(cast(c AS int)+cast(c AS int)) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND bitwise_convert_long_bits_to_double(cast(c AS int)+cast(c AS int))<>99999);
++-----+
+| cnt |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B27_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT bitwise_convert_long_bits_to_double(cast(c AS int))+bitwise_convert_long_bits_to_double(c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND (bitwise_convert_long_bits_to_double(cast(c AS int))+bitwise_convert_long_bits_to_double(c_long))<>99999);
++-----+
+| cnt |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B27_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT bitwise_convert_long_bits_to_double(cast(c AS int)+c_long) AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND bitwise_convert_long_bits_to_double(cast(c AS int)+c_long)<>99999);
++-----+
+| cnt |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(cast(c AS int), 1)+bitwise_or(cast(c AS int), 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (bitwise_or(cast(c AS int), 1)+bitwise_or(cast(c AS int), 1)) IN (2,
+                                                                        6);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   6 |
+|   6 |
+|   6 |
+|   6 |
+|   6 |
+|   6 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B28_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(cast(c AS int), cast(c AS int)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND bitwise_or(cast(c AS int), cast(c AS int)) IN (0,
+                                                     1,
+                                                     2,
+                                                     3);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B28_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(cast(c AS int), 1)+bitwise_or(c_long, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (bitwise_or(cast(c AS int), 1)+bitwise_or(c_long, 1)) IN (2,
+                                                                4,
+                                                                6);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   4 |
+|   4 |
+|   4 |
+|   4 |
+|   4 |
+|   6 |
+|   6 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B28_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(cast(c AS int), c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND bitwise_or(cast(c AS int), c_long) IN (0,
+                                             1,
+                                             2,
+                                             3);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B29_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(cast(c AS int), 1)+bitwise_shift_left(cast(c AS int), 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (bitwise_shift_left(cast(c AS int), 1)+bitwise_shift_left(cast(c AS int), 1)) IN (0,
+                                                                                        4,
+                                                                                        8,
+                                                                                        12);
++-----+
+| col |
++-----+
+|  12 |
+|  12 |
+|  12 |
+|   4 |
+|   4 |
+|   4 |
+|   8 |
+|   8 |
+|   8 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B29_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(cast(c AS int), cast(c AS int)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND bitwise_shift_left(cast(c AS int), cast(c AS int)) IN (0,
+                                                             2,
+                                                             8,
+                                                             24);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|  24 |
+|  24 |
+|  24 |
+|   8 |
+|   8 |
+|   8 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B29_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(cast(c AS int), 1)+bitwise_shift_left(c_long, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (bitwise_shift_left(cast(c AS int), 1)+bitwise_shift_left(c_long, 1)) IN (0,
+                                                                                2,
+                                                                                4,
+                                                                                6,
+                                                                                8,
+                                                                                10);
++-----+
+| col |
++-----+
+|  10 |
+|   2 |
+|   4 |
+|   4 |
+|   6 |
+|   6 |
+|   6 |
+|   8 |
+|   8 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B29_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(cast(c AS int), c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND bitwise_shift_left(cast(c AS int), c_long) IN (0,
+                                                     1,
+                                                     2,
+                                                     3,
+                                                     4,
+                                                     6,
+                                                     8,
+                                                     12);
++-----+
+| col |
++-----+
+|   1 |
+|  12 |
+|   2 |
+|   2 |
+|   3 |
+|   4 |
+|   4 |
+|   6 |
+|   8 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B30_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(cast(c AS int), 1)+bitwise_shift_right(cast(c AS int), 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (bitwise_shift_right(cast(c AS int), 1)+bitwise_shift_right(cast(c AS int), 1)) IN (0,
+                                                                                          2);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B30_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(cast(c AS int), cast(c AS int)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND bitwise_shift_right(cast(c AS int), cast(c AS int)) IN (0);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B30_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(cast(c AS int), 1)+bitwise_shift_right(c_long, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (bitwise_shift_right(cast(c AS int), 1)+bitwise_shift_right(c_long, 1)) IN (0,
+                                                                                  1,
+                                                                                  2);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B30_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(cast(c AS int), c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND bitwise_shift_right(cast(c AS int), c_long) IN (0,
+                                                      1,
+                                                      2,
+                                                      3);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   3 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B31_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(cast(c AS int), 1)+bitwise_xor(cast(c AS int), 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (bitwise_xor(cast(c AS int), 1)+bitwise_xor(cast(c AS int), 1)) IN (0,
+                                                                          2,
+                                                                          4,
+                                                                          6);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   4 |
+|   4 |
+|   4 |
+|   6 |
+|   6 |
+|   6 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B31_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(cast(c AS int), cast(c AS int)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND bitwise_xor(cast(c AS int), cast(c AS int)) IN (0);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B31_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(cast(c AS int), 1)+bitwise_xor(c_long, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (bitwise_xor(cast(c AS int), 1)+bitwise_xor(c_long, 1)) IN (0,
+                                                                  1,
+                                                                  2,
+                                                                  3,
+                                                                  4,
+                                                                  5,
+                                                                  6);
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   2 |
+|   3 |
+|   3 |
+|   3 |
+|   4 |
+|   5 |
+|   6 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B31_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(cast(c AS int), c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND bitwise_xor(cast(c AS int), c_long) IN (0,
+                                              1,
+                                              2,
+                                              3);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B33_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(cast(c AS int))+human_readable_binary_byte_format(cast(c AS int)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (human_readable_binary_byte_format(cast(c AS int))+human_readable_binary_byte_format(cast(c AS int)))<>99999;
++-----+
+| col |
++-----+
++-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B33_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(cast(c AS int)+cast(c AS int)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND human_readable_binary_byte_format(cast(c AS int)+cast(c AS int)) IS NOT NULL;
++-----+
+| col |
++-----+
+| 2 B |
+| 2 B |
+| 2 B |
+| 4 B |
+| 4 B |
+| 4 B |
+| 6 B |
+| 6 B |
+| 6 B |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B33_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(cast(c AS int))+human_readable_binary_byte_format(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (human_readable_binary_byte_format(cast(c AS int))+human_readable_binary_byte_format(c_long))<>99999;
++-----+
+| col |
++-----+
++-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B33_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(cast(c AS int)+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND human_readable_binary_byte_format(c+c_long) IS NOT NULL;
++-----+
+| col |
++-----+
+| 1 B |
+| 2 B |
+| 2 B |
+| 3 B |
+| 3 B |
+| 3 B |
+| 4 B |
+| 4 B |
+| 5 B |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B34_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(cast(c AS int))+human_readable_decimal_byte_format(cast(c AS int)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (human_readable_decimal_byte_format(cast(c AS int))+human_readable_decimal_byte_format(cast(c AS int)))<>99999;
++-----+
+| col |
++-----+
++-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B34_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(cast(c AS int)+cast(c AS int)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND human_readable_decimal_byte_format(cast(c AS int)+cast(c AS int)) IS NOT NULL;
++-----+
+| col |
++-----+
+| 2 B |
+| 2 B |
+| 2 B |
+| 4 B |
+| 4 B |
+| 4 B |
+| 6 B |
+| 6 B |
+| 6 B |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B34_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(cast(c AS int))+human_readable_decimal_byte_format(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (human_readable_decimal_byte_format(cast(c AS int))+human_readable_decimal_byte_format(c_long))<>99999;
++-----+
+| col |
++-----+
++-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B34_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(cast(c AS int)+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND human_readable_decimal_byte_format(cast(c AS int)+c_long) IS NOT NULL;
++-----+
+| col |
++-----+
+| 1 B |
+| 2 B |
+| 2 B |
+| 3 B |
+| 3 B |
+| 3 B |
+| 4 B |
+| 4 B |
+| 5 B |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B35_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(cast(c AS int))+human_readable_decimal_format(cast(c AS int)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (human_readable_decimal_format(cast(c AS int))+human_readable_decimal_format(cast(c AS int))) IN (0,
+                                                                                                        2,
+                                                                                                        4,
+                                                                                                        6);
++-----+
+| col |
++-----+
+| 2.0 |
+| 2.0 |
+| 2.0 |
+| 4.0 |
+| 4.0 |
+| 4.0 |
+| 6.0 |
+| 6.0 |
+| 6.0 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B35_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(cast(c AS int)+cast(c AS int)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND human_readable_decimal_format(cast(c AS int)+cast(c AS int)) IN (0,
+                                                                       2,
+                                                                       4,
+                                                                       6);
++-----+
+| col |
++-----+
+| 2   |
+| 2   |
+| 2   |
+| 4   |
+| 4   |
+| 4   |
+| 6   |
+| 6   |
+| 6   |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B35_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(cast(c AS int))+ceil(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND human_readable_decimal_format(cast(c AS int))+ceil(c_long) IN (0,
+                                                                     1,
+                                                                     2,
+                                                                     3,
+                                                                     4,
+                                                                     5);
++-----+
+| col |
++-----+
+|   1 |
+|   2 |
+|   2 |
+|   3 |
+|   3 |
+|   3 |
+|   4 |
+|   4 |
+|   5 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B35_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(cast(c AS int)+c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND human_readable_decimal_format(cast(c AS int)+c_long) IN (0,
+                                                               1,
+                                                               2,
+                                                               3,
+                                                               4,
+                                                               5);
++-----+
+| col |
++-----+
+| 1   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
+| 4   |
+| 4   |
+| 5   |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B36_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(cast(c AS int), 0)+safe_divide(cast(c AS int), 0) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (safe_divide(cast(c AS int), 0)+safe_divide(cast(c AS int), 0)) IN (0);
++-----+
+| col |
++-----+
++-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B36_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(cast(c AS int), cast(c AS int)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND safe_divide(cast(c AS int), cast(c AS int)) IN (0,
+                                                      1);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B36_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(cast(c AS int), 0)+safe_divide(c_long, 0) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (safe_divide(cast(c AS int), 0)+safe_divide(c_long, 0)) IN (0);
++-----+
+| col |
++-----+
++-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_numeric_funcs TEST_ID: A1_B36_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(cast(c AS int), c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND safe_divide(cast(c AS int), c_long) IN (0,
+                                              1,
+                                              2,
+                                              3);
++-----+
+| col |
++-----+
+|   0 |
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   3 |
++-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(c, c)||concat(c, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (concat(c, c)||concat(c, c)) IN ('',
+                                       '1111',
+                                       '2222',
+                                       '3333');
++------+
+| col  |
++------+
+|      |
+|      |
+|      |
+| 1111 |
+| 1111 |
+| 1111 |
+| 2222 |
+| 2222 |
+| 2222 |
+| 3333 |
+| 3333 |
+| 3333 |
++------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(c, c_long)||concat(c, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (concat(c, c_long)||concat(c, c_long)) IN ('00',
+                                                 '1010',
+                                                 '2020',
+                                                 '3030',
+                                                 '11',
+                                                 '1111',
+                                                 '2121',
+                                                 '3131',
+                                                 '22',
+                                                 '1212',
+                                                 '2222',
+                                                 '3232');
++------+
+| col  |
++------+
+| 00   |
+| 1010 |
+| 11   |
+| 1111 |
+| 1212 |
+| 2020 |
+| 2121 |
+| 22   |
+| 2222 |
+| 3030 |
+| 3131 |
+| 3232 |
++------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(c, c)||textcat(c, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (textcat(c, c)||textcat(c, c)) IN ('',
+                                         '1111',
+                                         '2222',
+                                         '3333');
++------+
+| col  |
++------+
+|      |
+|      |
+|      |
+| 1111 |
+| 1111 |
+| 1111 |
+| 2222 |
+| 2222 |
+| 2222 |
+| 3333 |
+| 3333 |
+| 3333 |
++------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(c, cast(c_long AS char))||textcat(c, cast(c_long AS char)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (textcat(c, cast(c_long AS char))||textcat(c, cast(c_long AS char))) IN ('00',
+                                                                               '1010',
+                                                                               '2020',
+                                                                               '3030',
+                                                                               '11',
+                                                                               '1111',
+                                                                               '2121',
+                                                                               '3131',
+                                                                               '22',
+                                                                               '1212',
+                                                                               '2222',
+                                                                               '3232');
++------+
+| col  |
++------+
+| 00   |
+| 1010 |
+| 11   |
+| 1111 |
+| 1212 |
+| 2020 |
+| 2121 |
+| 22   |
+| 2222 |
+| 3030 |
+| 3131 |
+| 3232 |
++------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_format('%sZ', c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND string_format('%sZ', c) IN ('nullZ',
+                                  '1Z',
+                                  '2Z',
+                                  '3Z');
++-------+
+| col   |
++-------+
+| 1Z    |
+| 1Z    |
+| 1Z    |
+| 2Z    |
+| 2Z    |
+| 2Z    |
+| 3Z    |
+| 3Z    |
+| 3Z    |
+| nullZ |
+| nullZ |
+| nullZ |
++-------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B3_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_format('%sZ', c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND string_format('%sZ', c_long) IN ('0Z',
+                                       '1Z',
+                                       '2Z');
++-----+
+| col |
++-----+
+| 0Z  |
+| 0Z  |
+| 0Z  |
+| 0Z  |
+| 0Z  |
+| 1Z  |
+| 1Z  |
+| 1Z  |
+| 1Z  |
+| 1Z  |
+| 2Z  |
+| 2Z  |
+| 2Z  |
+| 2Z  |
+| 2Z  |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND length(c) IN (0,
+                    1);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B4_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND length(c_long) IN (1);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND char_length(c) IN (0,
+                         1);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B5_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND char_length(c_long) IN (1);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND character_length(c) IN (0,
+                              1);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B6_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND character_length(c_long) IN (1);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND strlen(c) IN (0,
+                    1);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B7_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND strlen(c_long) IN (1);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND lower(c)!='ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B8_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND lower(c_long) IN ('0',
+                        '1',
+                        '2');
++-----+
+| col |
++-----+
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND upper(c)!='ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B9_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND upper(c_long) IN ('0',
+                        '1',
+                        '2');
++-----+
+| col |
++-----+
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND parse_long(c) IN (0,
+                        1,
+                        2,
+                        3);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B10_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(cast(c_long AS char)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND parse_long(cast(c_long AS char)) IN (0,
+                                           1,
+                                           2);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position(c IN c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND position(c IN c) IN (1);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B11_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position(c_long IN c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND position(c_long IN c) IN (0,
+                                1);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   1 |
+|   1 |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position(c IN c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND position(c IN c_long) IN (0,
+                                1);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B11_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position(c_long IN c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND position(c_long IN c_long) IN (1);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(c, '.*') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND regexp_extract(c, '.*')!='ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B12_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(cast(c_long AS char), '.*') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND regexp_extract(cast(c_long AS char), '.*')!='ABCD';
++-----+
+| col |
++-----+
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(c, '.*') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2);
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+|      |
+|      |
+|      |
++------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B13_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(cast(c_long AS char), '.*') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND regexp_like(cast(c_long AS char), '.*') IS TRUE;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
+| true |
++------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(c, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (contains_string(c, '1') IS TRUE
+       OR contains_string(c, '1') IS FALSE);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
++-------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B14_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(cast(c_long AS char), '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (contains_string(cast(c_long AS char), '1') IS TRUE
+       OR contains_string(cast(c_long AS char), '1') IS FALSE);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
++-------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(c, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (icontains_string(c, '1') IS TRUE
+       OR icontains_string(c, '1') IS FALSE);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
++-------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B15_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(cast(c_long AS char), '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (icontains_string(cast(c_long AS char), '1') IS TRUE
+       OR icontains_string(cast(c_long AS char), '1') IS FALSE);
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| false |
+| true  |
+| true  |
+| true  |
+| true  |
+| true  |
++-------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B16_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(c, '1', 'Z') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND replace(c, '1', 'Z')<>'ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
+| Z   |
+| Z   |
+| Z   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B16_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(c_long, '1', 'Z') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND replace(c_long, '1', 'Z')<>'ABCD';
++-----+
+| col |
++-----+
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| Z   |
+| Z   |
+| Z   |
+| Z   |
+| Z   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(c, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND strpos(c, c) IN (1);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B17_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(cast(c_long AS char), c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND strpos(cast(c_long AS char), c) IN (0,
+                                          1);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(c, cast(c_long AS char)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND strpos(c, cast(c_long AS char)) IN (0,
+                                          1);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   1 |
+|   1 |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B17_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(cast(c_long AS char), cast(c_long AS char)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND strpos(cast(c_long AS char), cast(c_long AS char)) IN (1);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(c, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND substring(c, 1)<>'ABCD';
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B18_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(cast(c_long AS char), 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND substring(cast(c_long AS char), 1) IN ('0',
+                                             '1',
+                                             '2');
++-----+
+| col |
++-----+
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(c, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND right(c, 1)<>'ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B19_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(cast(c_long AS char), 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND right(cast(c_long AS char), 1) IN ('0',
+                                         '1',
+                                         '2');
++-----+
+| col |
++-----+
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(c, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND left(c, 1)<>'ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B20_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(cast(c_long AS char), 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND left(cast(c_long AS char), 1) IN ('0',
+                                        '1',
+                                        '2');
++-----+
+| col |
++-----+
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(c, 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND substr(c, 1)<>'ABCD';
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B21_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(cast(c_long AS char), 1) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND substr(cast(c_long AS char), 1) IN ('0',
+                                          '1',
+                                          '2');
++-----+
+| col |
++-----+
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH '1'
+            FROM c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND trim(BOTH '1'
+           FROM c)<>'ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B22_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH '1'
+            FROM c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND trim(BOTH '1'
+           FROM c_long)<>'ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(c, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND btrim(c, '1')<>'ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B23_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(cast(c_long AS char), '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND btrim(cast(c_long AS char), '1')<>'ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(c, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND ltrim(c, '1')<>'ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B24_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(cast(c_long AS char), '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND ltrim(cast(c_long AS char), '1')<>'ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(c, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND rtrim(c, '1')<>'ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B25_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(cast(c_long AS char), '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND rtrim(cast(c_long AS char), '1')<>'ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND reverse(c)<>'ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B26_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(cast(c_long AS char)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND reverse(cast(c_long AS char)) IN ('0',
+                                        '1',
+                                        '2');
++-----+
+| col |
++-----+
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(c, 2) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND repeat(c, 2)<>'ABCD';
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 11  |
+| 11  |
+| 11  |
+| 22  |
+| 22  |
+| 22  |
+| 33  |
+| 33  |
+| 33  |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B27_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(cast(c_long AS char), 2) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND repeat(cast(c_long AS char), 2) IN ('00',
+                                          '11',
+                                          '22');
++-----+
+| col |
++-----+
+| 00  |
+| 00  |
+| 00  |
+| 00  |
+| 00  |
+| 11  |
+| 11  |
+| 11  |
+| 11  |
+| 11  |
+| 22  |
+| 22  |
+| 22  |
+| 22  |
+| 22  |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(c, 3, 'Z') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND lpad(c, 3, 'Z')<>'ABCD';
++-----+
+| col |
++-----+
+| ZZ1 |
+| ZZ1 |
+| ZZ1 |
+| ZZ2 |
+| ZZ2 |
+| ZZ2 |
+| ZZ3 |
+| ZZ3 |
+| ZZ3 |
+| ZZZ |
+| ZZZ |
+| ZZZ |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B28_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(cast(c_long AS char), 3, 'Z') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND lpad(cast(c_long AS char), 3, 'Z') IN ('ZZ0',
+                                             'ZZ1',
+                                             'ZZ2');
++-----+
+| col |
++-----+
+| ZZ0 |
+| ZZ0 |
+| ZZ0 |
+| ZZ0 |
+| ZZ0 |
+| ZZ1 |
+| ZZ1 |
+| ZZ1 |
+| ZZ1 |
+| ZZ1 |
+| ZZ2 |
+| ZZ2 |
+| ZZ2 |
+| ZZ2 |
+| ZZ2 |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B29_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(c, 3, 'Z') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND rpad(c, 3, 'Z')<>'ABCD';
++-----+
+| col |
++-----+
+| 1ZZ |
+| 1ZZ |
+| 1ZZ |
+| 2ZZ |
+| 2ZZ |
+| 2ZZ |
+| 3ZZ |
+| 3ZZ |
+| 3ZZ |
+| ZZZ |
+| ZZZ |
+| ZZZ |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_string_funcs TEST_ID: A1_B29_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(cast(c_long AS char), 3, 'Z') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND rpad(cast(c_long AS char), 3, 'Z') IN ('0ZZ',
+                                             '1ZZ',
+                                             '2ZZ');
++-----+
+| col |
++-----+
+| 0ZZ |
+| 0ZZ |
+| 0ZZ |
+| 0ZZ |
+| 0ZZ |
+| 1ZZ |
+| 1ZZ |
+| 1ZZ |
+| 1ZZ |
+| 1ZZ |
+| 2ZZ |
+| 2ZZ |
+| 2ZZ |
+| 2ZZ |
+| 2ZZ |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT CURRENT_TIMESTAMP AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND CURRENT_TIMESTAMP IS NOT NULL);
++-----+
+| cnt |
++-----+
+|  15 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT CURRENT_DATE AS col
+   FROM test_unnest,
+        unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+   WHERE c_long IN (0,
+                    1,
+                    2)
+     AND CURRENT_DATE IS NOT NULL);
++-----+
+| cnt |
++-----+
+|  15 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B3_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND date_trunc('year', c) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B3_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND date_trunc('year', c_long) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B4_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(c, 'P1D') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND time_ceil(c, 'P1D') IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B4_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(c_long, 'P1D') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND time_ceil(c_long, 'P1D') IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B5_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(c, 'P1D') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND time_floor(c, 'P1D') IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B5_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(c_long, 'P1D') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND time_floor(c_long, 'P1D') IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B6_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(c, 'P1D') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND time_shift(c, 'P1D') IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B6_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(c_long, 'P1D') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND time_shift(c_long, 'P1D') IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B7_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(c, 'HOUR') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND time_extract(c, 'HOUR') IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B7_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(c_long, 'HOUR') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND time_extract(c_long, 'HOUR') IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND time_parse(c) IS NOT NULL;
++-------------------------+
+| col                     |
++-------------------------+
+| 0001-01-01 00:00:00.000 |
+| 0001-01-01 00:00:00.000 |
+| 0001-01-01 00:00:00.000 |
+| 0002-01-01 00:00:00.000 |
+| 0002-01-01 00:00:00.000 |
+| 0002-01-01 00:00:00.000 |
+| 0003-01-01 00:00:00.000 |
+| 0003-01-01 00:00:00.000 |
+| 0003-01-01 00:00:00.000 |
++-------------------------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B8_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(cast(c_long AS char)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND time_parse(cast(c_long AS char)) IS NOT NULL;
++-------------------------+
+| col                     |
++-------------------------+
+| 0000-01-01 00:00:00.000 |
+| 0000-01-01 00:00:00.000 |
+| 0000-01-01 00:00:00.000 |
+| 0000-01-01 00:00:00.000 |
+| 0000-01-01 00:00:00.000 |
+| 0001-01-01 00:00:00.000 |
+| 0001-01-01 00:00:00.000 |
+| 0001-01-01 00:00:00.000 |
+| 0001-01-01 00:00:00.000 |
+| 0001-01-01 00:00:00.000 |
+| 0002-01-01 00:00:00.000 |
+| 0002-01-01 00:00:00.000 |
+| 0002-01-01 00:00:00.000 |
+| 0002-01-01 00:00:00.000 |
+| 0002-01-01 00:00:00.000 |
++-------------------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B9_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(c, '2001-01-01/P1D') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND time_in_interval(c, '2001-01-01/P1D') IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B9_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(c_long, '2001-01-01/P1D') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND time_in_interval(c, '2001-01-01/P1D') IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(cast(c AS int)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND millis_to_timestamp(cast(c AS int))<>'2000-01-01T00:00:00.000Z';
++-------------------------+
+| col                     |
++-------------------------+
+| 1970-01-01 00:00:00.001 |
+| 1970-01-01 00:00:00.001 |
+| 1970-01-01 00:00:00.001 |
+| 1970-01-01 00:00:00.002 |
+| 1970-01-01 00:00:00.002 |
+| 1970-01-01 00:00:00.002 |
+| 1970-01-01 00:00:00.003 |
+| 1970-01-01 00:00:00.003 |
+| 1970-01-01 00:00:00.003 |
+|                         |
+|                         |
+|                         |
++-------------------------+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B10_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND millis_to_timestamp(c_long)<>'2000-01-01T00:00:00.000Z';
++-------------------------+
+| col                     |
++-------------------------+
+| 1970-01-01 00:00:00.000 |
+| 1970-01-01 00:00:00.000 |
+| 1970-01-01 00:00:00.000 |
+| 1970-01-01 00:00:00.000 |
+| 1970-01-01 00:00:00.000 |
+| 1970-01-01 00:00:00.001 |
+| 1970-01-01 00:00:00.001 |
+| 1970-01-01 00:00:00.001 |
+| 1970-01-01 00:00:00.001 |
+| 1970-01-01 00:00:00.001 |
+| 1970-01-01 00:00:00.002 |
+| 1970-01-01 00:00:00.002 |
+| 1970-01-01 00:00:00.002 |
+| 1970-01-01 00:00:00.002 |
+| 1970-01-01 00:00:00.002 |
++-------------------------+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B11_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND timestamp_to_millis(c) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B11_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND timestamp_to_millis(c_long) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B12_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND extract(DAY
+              FROM c) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B12_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND extract(DAY
+              FROM c_long) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B13_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(c TO DAY) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND floor(c TO DAY) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B13_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(c_long TO DAY) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND floor(c_long TO DAY) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B14_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(c TO DAY) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND ceil(c TO DAY) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B14_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(c_long TO DAY) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND ceil(c_long TO DAY) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B15_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND timestampadd(DAY, 1, c) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B15_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND timestampadd(DAY, 1, c_long) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B16_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, c, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND timestampdiff(DAY, c, c) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B16_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, c_long, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND timestampdiff(DAY, c_long, c) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B16_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, c, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND timestampdiff(DAY, c, c_long) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_datetime_funcs TEST_ID: A1_B16_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, c_long, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND timestampdiff(DAY, c_long, c_long) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_reduction_funcs TEST_ID: A1_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(c, c, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND greatest(c, c, '1') IN ('1',
+                              '2',
+                              '3');
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_reduction_funcs TEST_ID: A1_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(c, c_long, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND greatest(c, c_long, '1') IN ('1',
+                                   '2',
+                                   '3');
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_reduction_funcs TEST_ID: A1_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(c, c, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND least(c, c, '1') IN ('1');
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_reduction_funcs TEST_ID: A1_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(c, c_long, '1') AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND least(c, c_long, '1') IN ('0',
+                                '1');
++-----+
+| col |
++-----+
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_ipaddr_funcs TEST_ID: A1_B1_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ip4_match(c, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND ip4_match(c, c) IS TRUE;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_ipaddr_funcs TEST_ID: A1_B1_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ip4_match(c, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND ip4_match(c, c_long) IS TRUE;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_ipaddr_funcs TEST_ID: A1_B2_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ip4_parse(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND ip4_parse(c) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_ipaddr_funcs TEST_ID: A1_B2_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ip4_parse(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND ip4_parse(c_long) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_ipaddr_funcs TEST_ID: A1_B3_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ip4_stringify(c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND ip4_stringify(c) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_ipaddr_funcs TEST_ID: A1_B3_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ip4_stringify(c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND ip4_stringify(c_long) IS NOT NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(c AS int) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (c IS NULL
+       OR cast(c AS int) IN (1,
+                             2,
+                             3));
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|   3 |
+|   3 |
+|   3 |
+|     |
+|     |
+|     |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(c_long AS char) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND cast(c_long AS char) IN ('0',
+                               '1',
+                               '2');
++-----+
+| col |
++-----+
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE c
+            WHEN '1' THEN 'V1'
+            ELSE 'V2'
+        END) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (CASE c
+           WHEN '1' THEN 'V1'
+           ELSE 'V2'
+       END) IN ('V1',
+                'V2');
++-----+
+| col |
++-----+
+| V1  |
+| V1  |
+| V1  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE c_long
+            WHEN 1 THEN 'V1'
+            ELSE 'V2'
+        END) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (CASE c_long
+           WHEN 1 THEN 'V1'
+           ELSE 'V2'
+       END) IN ('V1',
+                'V2');
++-----+
+| col |
++-----+
+| V1  |
+| V1  |
+| V1  |
+| V1  |
+| V1  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN c='1' THEN 'V1'
+            ELSE 'V2'
+        END) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (CASE
+           WHEN c='1' THEN 'V1'
+           ELSE 'V2'
+       END) IN ('V1',
+                'V2');
++-----+
+| col |
++-----+
+| V1  |
+| V1  |
+| V1  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B3_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN c_long=1 THEN 'V1'
+            ELSE 'V2'
+        END) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND (CASE
+           WHEN c_long=1 THEN 'V1'
+           ELSE 'V2'
+       END) IN ('V1',
+                'V2');
++-----+
+| col |
++-----+
+| V1  |
+| V1  |
+| V1  |
+| V1  |
+| V1  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
+| V2  |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B4_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(c, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND nullif(c, c) IN ('',
+                       '1',
+                       '2',
+                       '3');
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B4_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(c, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND nullif(c, c_long) IN ('',
+                            '1',
+                            '2',
+                            '3');
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(10 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(c_long, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND cast(nullif(c_long, c) AS char) IN ('',
+                                          '0',
+                                          '1',
+                                          '2');
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(13 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B4_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(c_long, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND nullif(c_long, c_long) IS NULL;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
+|     |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(c, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND coalesce(c, c) IN ('',
+                         '1',
+                         '2',
+                         '3');
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B5_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(c, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND coalesce(c, c_long) IN (0,
+                              1,
+                              2,
+                              3);
++-----+
+| col |
++-----+
+| 0   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(c_long, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND coalesce(c_long, c) IN (0,
+                              1,
+                              2);
++-----+
+| col |
++-----+
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B5_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(c_long, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND coalesce(c_long, c_long) IN (0,
+                                   1,
+                                   2);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(c, c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND nvl(c, c) IN ('',
+                    '1',
+                    '2',
+                    '3');
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(12 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B6_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(c, cast(c_long AS char)) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND nvl(c, cast(c_long AS char)) IN (1,
+                                       2,
+                                       3);
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 3   |
+| 3   |
+| 3   |
++-----+
+(11 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(cast(c_long AS char), c) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND nvl(cast(c_long AS char), c) IN (0,
+                                       1,
+                                       2);
++-----+
+| col |
++-----+
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 0   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 1   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
+| 2   |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_other_funcs TEST_ID: A1_B6_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(c_long, c_long) AS col
+FROM test_unnest,
+     unnest(mv_to_array(c_mv_num_with_null_and_empty_val)) AS u(c)
+WHERE c_long IN (0,
+                 1,
+                 2)
+  AND nvl(c_long, c_long) IN (0,
+                              1,
+                              2);
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   0 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   1 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 261 Positive tests: 228 Negative tests: 33
+#-------------------------------------------------------------------------
diff --git a/sql/src/test/quidem/qatests/qaUnnest/array/ingest.json b/sql/src/test/quidem/qatests/qaUnnest/array/ingest.json
new file mode 100644
index 000000000000..548dca99bda6
--- /dev/null
+++ b/sql/src/test/quidem/qatests/qaUnnest/array/ingest.json
@@ -0,0 +1,92 @@
+{
+  "type": "index_parallel",
+  "spec": {
+    "ioConfig": {
+      "type": "index_parallel",
+      "inputSource": {
+        "type": "inline",
+        "data": "{\"timestamp\":\"2022-01-01T00:00:00\",\"s_int\":1,\"s_null\":null,\"a_bool\":[true,false,null],\"a_int\":[1,2,null],\"a_float\":[0.1,0.2,null],\"a_str\":[\"S1\",\"S2\",null],\"a_null\":[null,null,null],\"a_empty\":[],\"a_mixed\":[true,1,0.1,\"S1\",null],\"a_nested\":[[true,false,null],[1,2,null],[0.1,0.2,null],[\"S1\",\"S2\",null],[null,null,null],[],[true,1,0.1,\"S1\",null],[[true,false,null],[1,2,null],[0.1,0.2,null],[\"S1\",\"S2\",null],[null,null,null],[],[true,1,0.1,\"S1\",null],[[true,false,null],[1,2,null],[0.1,0.2,null],[\"S1\",\"S2\",null],[null,null,null],[],[true,1,0.1,\"S1\",null]]]]}\n{\"timestamp\":\"2022-02-01T00:00:00\",\"s_int\":2,\"s_null\":null,\"a_bool\":[null,true,false],\"a_int\":[null,1,2],\"a_float\":[null,0.1,0.2],\"a_str\":[null,\"S1\",\"S2\"],\"a_null\":[null,null,null],\"a_empty\":[],\"a_mixed\":[null,true,1,0.1,\"S1\"],\"a_nested\":[[null,true,false],[null,1,2],[null,0.1,0.2],[null,\"S1\",\"S2\"],[null,null,null],[],[null,true,1,0.1,\"S1\"],[[null,true,false],[null,1,2],[null,0.1,0.2],[null,\"S1\",\"S2\"],[null,null,null],[],[null,true,1,0.1,\"S1\"],[[null,true,false],[null,1,2],[null,0.1,0.2],[null,\"S1\",\"S2\"],[null,null,null],[],[null,true,1,0.1,\"S1\"]]]]}\n{\"timestamp\":\"2022-03-01T00:00:00\",\"s_int\":null,\"s_null\":null,\"a_bool\":[false,null,true],\"a_int\":[2,null,1],\"a_float\":[0.2,null,0.1],\"a_str\":[\"S2\",null,\"S1\"],\"a_null\":[null,null,null],\"a_empty\":[],\"a_mixed\":[\"S1\",null,true,1,0.1],\"a_nested\":[[false,null,true],[2,null,1],[0.2,null,0.1],[\"S2\",null,\"S1\"],[null,null,null],[],[\"S1\",null,true,1,0.1],[[false,null,true],[2,null,1],[0.2,null,0.1],[\"S2\",null,\"S1\"],[null,null,null],[],[\"S1\",null,true,1,0.1],[[false,null,true],[2,null,1],[0.2,null,0.1],[\"S2\",null,\"S1\"],[null,null,null],[],[\"S1\",null,true,1,0.1]]]]}\n"
+      },
+      "inputFormat": {
+        "type": "json"
+      },
+      "appendToExisting": false
+    },
+    "tuningConfig": {
+      "type": "index_parallel",
+      "partitionsSpec": {
+        "type": "dynamic",
+        "maxRowsPerSegment": 10000000,
+        "maxTotalRows": 500000000
+      },
+      "maxNumConcurrentSubTasks": 1,
+      "indexSpec": {
+        "stringDictionaryEncoding": {
+          "type": "frontCoded",
+          "bucketSize": 4,
+          "formatVersion": 1
+        }
+      }
+    },
+    "dataSchema": {
+      "dataSource": "test_unnest",
+      "granularitySpec": {
+        "type": "uniform",
+        "queryGranularity": "NONE",
+        "rollup": false,
+        "segmentGranularity": "YEAR"
+      },
+      "timestampSpec": {
+        "column": "timestamp",
+        "format": "auto"
+      },
+      "dimensionsSpec": {
+        "dimensions": [
+          {
+            "type": "auto",
+            "name": "s_int"
+          },
+          {
+            "type": "auto",
+            "name": "s_null"
+          },
+          {
+            "type": "auto",
+            "name": "a_bool"
+          },
+          {
+            "type": "auto",
+            "name": "a_int"
+          },
+          {
+            "type": "auto",
+            "name": "a_float"
+          },
+          {
+            "type": "auto",
+            "name": "a_str"
+          },
+          {
+            "type": "auto",
+            "name": "a_null"
+          },
+          {
+            "type": "auto",
+            "name": "a_empty"
+          },
+          {
+            "type": "auto",
+            "name": "a_mixed"
+          },
+          {
+            "type": "auto",
+            "name": "a_nested"
+          }
+        ]
+      },
+      "metricsSpec": null,
+      "transformSpec": null
+    }
+  },
+  "context": null
+}
diff --git a/sql/src/test/quidem/qatests/qaUnnest/mv/ingest.json b/sql/src/test/quidem/qatests/qaUnnest/mv/ingest.json
new file mode 100644
index 000000000000..ab63b7e70f85
--- /dev/null
+++ b/sql/src/test/quidem/qatests/qaUnnest/mv/ingest.json
@@ -0,0 +1,112 @@
+{
+  "type": "index_parallel",
+  "spec": {
+    "ioConfig": {
+      "type": "index_parallel",
+      "inputSource": {
+        "type": "inline",
+        "data": "{\"timestamp\":\"2022-01-01T00:00:00\",\"c_str\": null,\"c_long\": 0,\"c_float\": 0.0,\"c_double\": 0.0,\"c_null\": null,\"c_mv_complex\": [\"my_null\",\"my_empty\",\"1\",[\"2\"],[\"3\",[\"4\",\"5\"]]],\"c_mv_num\": [\"-1\",\"0\",\"1\",\"2\",\"3\"],\"c_mv_complex_with_null_and_empty_val\": [null,\"\",\"1\",[\"2\"],[\"3\",[\"4\",\"5\"]]],\"c_mv_num_with_null_and_empty_val\": [null,\"\",\"1\",\"2\",\"3\"],\"c_mv_complex_with_null_and_empty_row\": null,\"c_mv_num_with_null_and_empty_row\": null,\"c_mv_all_null_and_empty_val\": [null,\"\",null,\"\",null],\"c_mv_empty\": []}\n{\"timestamp\":\"2022-01-01T00:00:00\",\"c_str\": \"\",\"c_long\": 1,\"c_float\": 0.1,\"c_double\": 0.1,\"c_null\": null,\"c_mv_complex\": [\"my_null\",\"my_empty\",\"1\",[\"2\"],[\"3\",[\"4\",\"5\"]]],\"c_mv_num\": [\"-1\",\"0\",\"1\",\"2\",\"3\"],\"c_mv_complex_with_null_and_empty_val\": [null,\"\",\"1\",[\"2\"],[\"3\",[\"4\",\"5\"]]],\"c_mv_num_with_null_and_empty_val\": [null,\"\",\"1\",\"2\",\"3\"],\"c_mv_complex_with_null_and_empty_row\": [],\"c_mv_num_with_null_and_empty_row\": [],\"c_mv_all_null_and_empty_val\": [null,\"\",null,\"\",null],\"c_mv_empty\": []}\n{\"timestamp\":\"2022-01-01T00:00:00\",\"c_str\": \"str2\",\"c_long\": 2,\"c_float\": 0.2,\"c_double\": 0.2,\"c_null\": null,\"c_mv_complex\": [\"my_null\",\"my_empty\",\"1\",[\"2\"],[\"3\",[\"4\",\"5\"]]],\"c_mv_num\": [\"-1\",\"0\",\"1\",\"2\",\"3\"],\"c_mv_complex_with_null_and_empty_val\": [null,\"\",\"1\",[\"2\"],[\"3\",[\"4\",\"5\"]]],\"c_mv_num_with_null_and_empty_val\": [null,\"\",\"1\",\"2\",\"3\"],\"c_mv_complex_with_null_and_empty_row\": [null,\"\",\"1\",[\"2\"],[\"3\",[\"4\",\"5\"]]],\"c_mv_num_with_null_and_empty_row\": [null,\"\",\"1\",\"2\",\"3\"],\"c_mv_all_null_and_empty_val\": [null,\"\",null,\"\",null],\"c_mv_empty\": []}\n{\"timestamp\":\"2022-01-01T00:00:00\",\"c_str\": \"str3\",\"c_long\": 3,\"c_float\": 0.3,\"c_double\": 0.3,\"c_null\": null,\"c_mv_complex\": [\"my_null\",\"my_empty\",\"1\",[\"2\"],[\"3\",[\"4\",\"5\"]]],\"c_mv_num\": [\"-1\",\"0\",\"1\",\"2\",\"3\"],\"c_mv_complex_with_null_and_empty_val\": [null,\"\",\"1\",[\"2\"],[\"3\",[\"4\",\"5\"]]],\"c_mv_num_with_null_and_empty_val\": [null,\"\",\"1\",\"2\",\"3\"],\"c_mv_complex_with_null_and_empty_row\": [null,\"\",\"1\",[\"2\"],[\"3\",[\"4\",\"5\"]]],\"c_mv_num_with_null_and_empty_row\": [null,\"\",\"1\",\"2\",\"3\"],\"c_mv_all_null_and_empty_val\": [null,\"\",null,\"\",null],\"c_mv_empty\": []}\n{\"timestamp\":\"2022-01-01T00:00:00\",\"c_str\": \"str4\",\"c_long\": 4,\"c_float\": 0.4,\"c_double\": 0.4,\"c_null\": null,\"c_mv_complex\": [\"my_null\",\"my_empty\",\"1\",[\"2\"],[\"3\",[\"4\",\"5\"]]],\"c_mv_num\": [\"-1\",\"0\",\"1\",\"2\",\"3\"],\"c_mv_complex_with_null_and_empty_val\": [null,\"\",\"1\",[\"2\"],[\"3\",[\"4\",\"5\"]]],\"c_mv_num_with_null_and_empty_val\": [null,\"\",\"1\",\"2\",\"3\"],\"c_mv_complex_with_null_and_empty_row\": [null,\"\",\"1\",[\"2\"],[\"3\",[\"4\",\"5\"]]],\"c_mv_num_with_null_and_empty_row\": [null,\"\",\"1\",\"2\",\"3\"],\"c_mv_all_null_and_empty_val\": [null,\"\",null,\"\",null],\"c_mv_empty\": []}\n"
+      },
+      "inputFormat": {
+        "type": "json"
+      },
+      "appendToExisting": false
+    },
+    "tuningConfig": {
+      "type": "index_parallel",
+      "partitionsSpec": {
+        "type": "dynamic",
+        "maxRowsPerSegment": 10000000,
+        "maxTotalRows": 500000000
+      },
+      "maxNumConcurrentSubTasks": 1,
+      "indexSpec": {
+        "stringDictionaryEncoding": {
+          "type": "frontCoded",
+          "bucketSize": 4,
+          "formatVersion": 1
+        }
+      }
+    },
+    "dataSchema": {
+      "dataSource": "test_unnest",
+      "granularitySpec": {
+        "type": "uniform",
+        "queryGranularity": "NONE",
+        "rollup": false,
+        "segmentGranularity": "YEAR"
+      },
+      "timestampSpec": {
+        "column": "timestamp",
+        "format": "auto"
+      },
+      "dimensionsSpec": {
+        "dimensions": [
+          {
+            "type": "string",
+            "name": "c_str"
+          },
+          {
+            "type": "long",
+            "name": "c_long"
+          },
+          {
+            "type": "float",
+            "name": "c_float"
+          },
+          {
+            "type": "double",
+            "name": "c_double"
+          },
+          {
+            "type": "string",
+            "name": "c_null"
+          },
+          {
+            "type": "string",
+            "name": "c_mv_complex",
+            "multiValueHandling": "ARRAY"
+          },
+          {
+            "type": "string",
+            "name": "c_mv_num",
+            "multiValueHandling": "ARRAY"
+          },
+          {
+            "type": "string",
+            "name": "c_mv_complex_with_null_and_empty_val",
+            "multiValueHandling": "ARRAY"
+          },
+          {
+            "type": "string",
+            "name": "c_mv_num_with_null_and_empty_val",
+            "multiValueHandling": "ARRAY"
+          },
+          {
+            "type": "string",
+            "name": "c_mv_complex_with_null_and_empty_row",
+            "multiValueHandling": "ARRAY"
+          },
+          {
+            "type": "string",
+            "name": "c_mv_num_with_null_and_empty_row",
+            "multiValueHandling": "ARRAY"
+          },
+          {
+            "type": "string",
+            "name": "c_mv_all_null_and_empty_val",
+            "multiValueHandling": "ARRAY"
+          },
+          {
+            "type": "string",
+            "name": "c_mv_empty",
+            "multiValueHandling": "ARRAY"
+          }
+        ]
+      },
+      "metricsSpec": null,
+      "transformSpec": null
+    }
+  },
+  "context": null
+}

From 667ac33f50f15357c35e6d00eb81c52dcd6911e0 Mon Sep 17 00:00:00 2001
From: Vadim Ogievetsky <vadim@ogievetsky.com>
Date: Fri, 21 Mar 2025 06:34:12 -0700
Subject: [PATCH 47/99] Web console: show loader on aux queries (#17804)

* show loader on aux queries

* show supervisors if not on page 0

* refactor

* fix bug fetching data when columns are added or removed

* update test
---
 web-console/src/react-table/index.ts          |  2 +-
 ...ls.spec.ts => react-table-filters.spec.ts} |  2 +-
 ...-table-utils.ts => react-table-filters.ts} |  0
 .../src/react-table/react-table-inputs.tsx    |  2 +-
 .../src/utils/query-manager/query-manager.ts  |  4 +-
 .../datasources-view/datasources-view.tsx     | 39 ++++--------
 .../src/views/lookups-view/lookups-view.tsx   | 23 +++----
 .../src/views/segments-view/segments-view.tsx | 27 +++++----
 .../__snapshots__/services-view.spec.tsx.snap |  1 +
 .../src/views/services-view/services-view.tsx | 34 ++++++-----
 .../supervisors-view.spec.tsx.snap            |  1 +
 .../supervisors-view/supervisors-view.tsx     | 38 +++++++-----
 .../src/views/tasks-view/tasks-view.tsx       | 60 ++++++++++++++-----
 13 files changed, 133 insertions(+), 100 deletions(-)
 rename web-console/src/react-table/{react-table-utils.spec.ts => react-table-filters.spec.ts} (98%)
 rename web-console/src/react-table/{react-table-utils.ts => react-table-filters.ts} (100%)

diff --git a/web-console/src/react-table/index.ts b/web-console/src/react-table/index.ts
index 3f1900fb6109..65b62cff5b4d 100644
--- a/web-console/src/react-table/index.ts
+++ b/web-console/src/react-table/index.ts
@@ -16,6 +16,6 @@
  * limitations under the License.
  */
 
+export * from './react-table-filters';
 export * from './react-table-inputs';
 export * from './react-table-pagination/react-table-pagination';
-export * from './react-table-utils';
diff --git a/web-console/src/react-table/react-table-utils.spec.ts b/web-console/src/react-table/react-table-filters.spec.ts
similarity index 98%
rename from web-console/src/react-table/react-table-utils.spec.ts
rename to web-console/src/react-table/react-table-filters.spec.ts
index 1dd245b49f70..03737825cbd9 100644
--- a/web-console/src/react-table/react-table-utils.spec.ts
+++ b/web-console/src/react-table/react-table-filters.spec.ts
@@ -20,7 +20,7 @@ import {
   sqlQueryCustomTableFilter,
   stringToTableFilters,
   tableFiltersToString,
-} from './react-table-utils';
+} from './react-table-filters';
 
 describe('react-table-utils', () => {
   describe('sqlQueryCustomTableFilter', () => {
diff --git a/web-console/src/react-table/react-table-utils.ts b/web-console/src/react-table/react-table-filters.ts
similarity index 100%
rename from web-console/src/react-table/react-table-utils.ts
rename to web-console/src/react-table/react-table-filters.ts
diff --git a/web-console/src/react-table/react-table-inputs.tsx b/web-console/src/react-table/react-table-inputs.tsx
index 79932b490e4f..6794cff42822 100644
--- a/web-console/src/react-table/react-table-inputs.tsx
+++ b/web-console/src/react-table/react-table-inputs.tsx
@@ -31,7 +31,7 @@ import {
   filterModeToIcon,
   filterModeToTitle,
   parseFilterModeAndNeedle,
-} from './react-table-utils';
+} from './react-table-filters';
 
 interface FilterRendererProps {
   column: Column;
diff --git a/web-console/src/utils/query-manager/query-manager.ts b/web-console/src/utils/query-manager/query-manager.ts
index 1023b23412ad..0b7fcf5680ed 100644
--- a/web-console/src/utils/query-manager/query-manager.ts
+++ b/web-console/src/utils/query-manager/query-manager.ts
@@ -246,8 +246,8 @@ export class QueryManager<Q, R, I = never, E extends Error = Error> {
   }
 
   private trigger() {
-    if (this.currentRunCancelFn) {
-      // Currently loading
+    if (this.currentRunCancelFn && !this.state.auxiliaryLoading) {
+      // Currently loading main query
       void this.runWhenLoading();
     } else {
       this.setState(
diff --git a/web-console/src/views/datasources-view/datasources-view.tsx b/web-console/src/views/datasources-view/datasources-view.tsx
index 4921027100ad..ea0df40bb0a4 100644
--- a/web-console/src/views/datasources-view/datasources-view.tsx
+++ b/web-console/src/views/datasources-view/datasources-view.tsx
@@ -527,9 +527,7 @@ GROUP BY 1, 2`;
                 return datasourcesAndDefaultRules;
               }
             });
-          }
-
-          if (capabilities.hasOverlordAccess()) {
+          } else if (capabilities.hasOverlordAccess()) {
             auxiliaryQueries.push(async (datasourcesAndDefaultRules, cancelToken) => {
               try {
                 const taskList = await getApiArray(
@@ -684,14 +682,14 @@ GROUP BY 1, 2`;
     }
   };
 
-  private fetchDatasourceData() {
+  private readonly fetchData = () => {
     const { capabilities } = this.props;
     const { visibleColumns, showUnused } = this.state;
     this.datasourceQueryManager.runQuery({ capabilities, visibleColumns, showUnused });
-  }
+  };
 
   componentDidMount(): void {
-    this.fetchDatasourceData();
+    this.fetchData();
   }
 
   componentWillUnmount(): void {
@@ -730,9 +728,7 @@ GROUP BY 1, 2`;
         onClose={() => {
           this.setState({ datasourceToMarkAsUnusedAllSegmentsIn: undefined });
         }}
-        onSuccess={() => {
-          this.fetchDatasourceData();
-        }}
+        onSuccess={this.fetchData}
       >
         <p>
           {`Are you sure you want to mark as unused all segments in '${datasourceToMarkAsUnusedAllSegmentsIn}'?`}
@@ -774,9 +770,7 @@ GROUP BY 1, 2`;
         onClose={() => {
           this.setState({ datasourceToMarkAllNonOvershadowedSegmentsAsUsedIn: undefined });
         }}
-        onSuccess={() => {
-          this.fetchDatasourceData();
-        }}
+        onSuccess={this.fetchData}
       >
         <p>{`Are you sure you want to mark as used all non-overshadowed segments in '${datasourceToMarkAllNonOvershadowedSegmentsAsUsedIn}'?`}</p>
       </AsyncActionDialog>
@@ -811,9 +805,7 @@ GROUP BY 1, 2`;
         onClose={() => {
           this.setState({ datasourceToMarkSegmentsByIntervalIn: undefined });
         }}
-        onSuccess={() => {
-          this.fetchDatasourceData();
-        }}
+        onSuccess={this.fetchData}
       >
         <p>{`Please select the interval in which you want to mark segments as ${usedWord} in '${datasourceToMarkSegmentsByIntervalIn}'?`}</p>
         <FormGroup>
@@ -840,9 +832,7 @@ GROUP BY 1, 2`;
         onClose={() => {
           this.setState({ killDatasource: undefined });
         }}
-        onSuccess={() => {
-          this.fetchDatasourceData();
-        }}
+        onSuccess={this.fetchData}
       />
     );
   }
@@ -930,7 +920,7 @@ GROUP BY 1, 2`;
       message: 'Retention rules submitted successfully',
       intent: Intent.SUCCESS,
     });
-    this.fetchDatasourceData();
+    this.fetchData();
   };
 
   private readonly editDefaultRules = () => {
@@ -956,7 +946,7 @@ GROUP BY 1, 2`;
     try {
       await Api.instance.post(`/druid/coordinator/v1/config/compaction`, compactionConfig);
       this.setState({ compactionDialogOpenOn: undefined });
-      this.fetchDatasourceData();
+      this.fetchData();
     } catch (e) {
       AppToaster.show({
         message: getDruidErrorMessage(e),
@@ -980,7 +970,7 @@ GROUP BY 1, 2`;
             await Api.instance.delete(
               `/druid/coordinator/v1/config/compaction/${Api.encodePath(datasource)}`,
             );
-            this.setState({ compactionDialogOpenOn: undefined }, () => this.fetchDatasourceData());
+            this.setState({ compactionDialogOpenOn: undefined }, () => this.fetchData());
           } catch (e) {
             AppToaster.show({
               message: getDruidErrorMessage(e),
@@ -995,7 +985,7 @@ GROUP BY 1, 2`;
   private toggleUnused(showUnused: boolean) {
     this.setState({ showUnused: !showUnused }, () => {
       if (showUnused) return;
-      this.fetchDatasourceData();
+      this.fetchData();
     });
   }
 
@@ -1759,10 +1749,7 @@ GROUP BY 1, 2`;
                 visibleColumns: prevState.visibleColumns.toggle(column),
               }))
             }
-            onClose={added => {
-              if (!added) return;
-              this.fetchDatasourceData();
-            }}
+            onClose={this.fetchData}
             tableColumnsHidden={visibleColumns.getHiddenColumns()}
           />
         </ViewControlBar>
diff --git a/web-console/src/views/lookups-view/lookups-view.tsx b/web-console/src/views/lookups-view/lookups-view.tsx
index 25f45455e224..39b7a920f1cb 100644
--- a/web-console/src/views/lookups-view/lookups-view.tsx
+++ b/web-console/src/views/lookups-view/lookups-view.tsx
@@ -332,17 +332,18 @@ export class LookupsView extends React.PureComponent<LookupsViewProps, LookupsVi
   private renderFilterableCell(field: string) {
     const { filters, onFiltersChange } = this.props;
 
-    // eslint-disable-next-line react/display-name
-    return (row: { value: any }) => (
-      <TableFilterableCell
-        field={field}
-        value={row.value}
-        filters={filters}
-        onFiltersChange={onFiltersChange}
-      >
-        {row.value}
-      </TableFilterableCell>
-    );
+    return function FilterableCell(row: { value: any }) {
+      return (
+        <TableFilterableCell
+          field={field}
+          value={row.value}
+          filters={filters}
+          onFiltersChange={onFiltersChange}
+        >
+          {row.value}
+        </TableFilterableCell>
+      );
+    };
   }
 
   private renderLookupsTable() {
diff --git a/web-console/src/views/segments-view/segments-view.tsx b/web-console/src/views/segments-view/segments-view.tsx
index ff3b0f76d8b7..ef44b83dc6ff 100644
--- a/web-console/src/views/segments-view/segments-view.tsx
+++ b/web-console/src/views/segments-view/segments-view.tsx
@@ -516,18 +516,19 @@ export class SegmentsView extends React.PureComponent<SegmentsViewProps, Segment
   ) {
     const { filters, onFiltersChange } = this.props;
 
-    // eslint-disable-next-line react/display-name
-    return (row: { value: any }) => (
-      <TableFilterableCell
-        field={field}
-        value={row.value}
-        filters={filters}
-        onFiltersChange={onFiltersChange}
-        enableComparisons={enableComparisons}
-      >
-        {valueFn(row.value)}
-      </TableFilterableCell>
-    );
+    return function FilterableCell(row: { value: any }) {
+      return (
+        <TableFilterableCell
+          field={field}
+          value={row.value}
+          filters={filters}
+          onFiltersChange={onFiltersChange}
+          enableComparisons={enableComparisons}
+        >
+          {valueFn(row.value)}
+        </TableFilterableCell>
+      );
+    };
   }
 
   renderSegmentsTable() {
@@ -580,7 +581,7 @@ export class SegmentsView extends React.PureComponent<SegmentsViewProps, Segment
         pageSize={pageSize}
         onPageSizeChange={pageSize => this.setState({ pageSize })}
         pageSizeOptions={STANDARD_TABLE_PAGE_SIZE_OPTIONS}
-        showPagination={segments.length >= STANDARD_TABLE_PAGE_SIZE}
+        showPagination={segments.length >= STANDARD_TABLE_PAGE_SIZE || page > 0}
         showPageJump={false}
         ofText=""
         pivotBy={groupByInterval ? ['interval'] : []}
diff --git a/web-console/src/views/services-view/__snapshots__/services-view.spec.tsx.snap b/web-console/src/views/services-view/__snapshots__/services-view.spec.tsx.snap
index b304833a8cce..2cf28b8b22ca 100644
--- a/web-console/src/views/services-view/__snapshots__/services-view.spec.tsx.snap
+++ b/web-console/src/views/services-view/__snapshots__/services-view.spec.tsx.snap
@@ -62,6 +62,7 @@ exports[`ServicesView renders data 1`] = `
         ]
       }
       onChange={[Function]}
+      onClose={[Function]}
       tableColumnsHidden={[]}
     />
   </Memo(ViewControlBar)>
diff --git a/web-console/src/views/services-view/services-view.tsx b/web-console/src/views/services-view/services-view.tsx
index 2a68eaed1cdc..58dca1410348 100644
--- a/web-console/src/views/services-view/services-view.tsx
+++ b/web-console/src/views/services-view/services-view.tsx
@@ -354,29 +354,34 @@ ORDER BY
   }
 
   componentDidMount(): void {
-    const { capabilities } = this.props;
-    const { visibleColumns } = this.state;
-    this.serviceQueryManager.runQuery({ capabilities, visibleColumns });
+    this.fetchData();
   }
 
   componentWillUnmount(): void {
     this.serviceQueryManager.terminate();
   }
 
+  private readonly fetchData = () => {
+    const { capabilities } = this.props;
+    const { visibleColumns } = this.state;
+    this.serviceQueryManager.runQuery({ capabilities, visibleColumns });
+  };
+
   private renderFilterableCell(field: string) {
     const { filters, onFiltersChange } = this.props;
 
-    // eslint-disable-next-line react/display-name
-    return (row: { value: any }) => (
-      <TableFilterableCell
-        field={field}
-        value={row.value}
-        filters={filters}
-        onFiltersChange={onFiltersChange}
-      >
-        {row.value}
-      </TableFilterableCell>
-    );
+    return function FilterableCell(row: { value: any }) {
+      return (
+        <TableFilterableCell
+          field={field}
+          value={row.value}
+          filters={filters}
+          onFiltersChange={onFiltersChange}
+        >
+          {row.value}
+        </TableFilterableCell>
+      );
+    };
   }
 
   renderServicesTable() {
@@ -837,6 +842,7 @@ ORDER BY
                 visibleColumns: prevState.visibleColumns.toggle(column),
               }))
             }
+            onClose={this.fetchData}
             tableColumnsHidden={visibleColumns.getHiddenColumns()}
           />
         </ViewControlBar>
diff --git a/web-console/src/views/supervisors-view/__snapshots__/supervisors-view.spec.tsx.snap b/web-console/src/views/supervisors-view/__snapshots__/supervisors-view.spec.tsx.snap
index a3fdd9212785..84b5cbe6e34a 100644
--- a/web-console/src/views/supervisors-view/__snapshots__/supervisors-view.spec.tsx.snap
+++ b/web-console/src/views/supervisors-view/__snapshots__/supervisors-view.spec.tsx.snap
@@ -93,6 +93,7 @@ exports[`SupervisorsView matches snapshot 1`] = `
         ]
       }
       onChange={[Function]}
+      onClose={[Function]}
       tableColumnsHidden={[]}
     />
   </Memo(ViewControlBar)>
diff --git a/web-console/src/views/supervisors-view/supervisors-view.tsx b/web-console/src/views/supervisors-view/supervisors-view.tsx
index a81fda3d7f00..8b692c26bfd1 100644
--- a/web-console/src/views/supervisors-view/supervisors-view.tsx
+++ b/web-console/src/views/supervisors-view/supervisors-view.tsx
@@ -67,6 +67,7 @@ import {
   changeByIndex,
   checkedCircleIcon,
   deepGet,
+  filterMap,
   formatByteRate,
   formatBytes,
   formatInteger,
@@ -333,9 +334,11 @@ export class SupervisorsView extends React.PureComponent<
 
           if (visibleColumns.shown('Stats')) {
             auxiliaryQueries.push(
-              ...supervisors.map(
-                (supervisor, i): AuxiliaryQueryFn<SupervisorQueryResultRow[]> =>
-                  async (rows, cancelToken) => {
+              ...filterMap(
+                supervisors,
+                (supervisor, i): AuxiliaryQueryFn<SupervisorQueryResultRow[]> | undefined => {
+                  if (oneOf(supervisor.type, 'autocompact', 'scheduled_batch')) return; // These supervisors do not report stats
+                  return async (rows, cancelToken) => {
                     const stats = (
                       await Api.instance.get(
                         `/druid/indexer/v1/supervisor/${Api.encodePath(
@@ -345,7 +348,8 @@ export class SupervisorsView extends React.PureComponent<
                       )
                     ).data;
                     return changeByIndex(rows, i, row => ({ ...row, stats }));
-                  },
+                  };
+                },
               ),
             );
           }
@@ -662,17 +666,18 @@ export class SupervisorsView extends React.PureComponent<
   private renderSupervisorFilterableCell(field: string) {
     const { filters, onFiltersChange } = this.props;
 
-    // eslint-disable-next-line react/display-name
-    return (row: { value: any }) => (
-      <TableFilterableCell
-        field={field}
-        value={row.value}
-        filters={filters}
-        onFiltersChange={onFiltersChange}
-      >
-        {row.value}
-      </TableFilterableCell>
-    );
+    return function SupervisorFilterableCell(row: { value: any }) {
+      return (
+        <TableFilterableCell
+          field={field}
+          value={row.value}
+          filters={filters}
+          onFiltersChange={onFiltersChange}
+        >
+          {row.value}
+        </TableFilterableCell>
+      );
+    };
   }
 
   private onSupervisorDetail(supervisor: SupervisorQueryResultRow) {
@@ -731,7 +736,7 @@ export class SupervisorsView extends React.PureComponent<
         pageSize={pageSize}
         onPageSizeChange={pageSize => this.setState({ pageSize })}
         pageSizeOptions={SMALL_TABLE_PAGE_SIZE_OPTIONS}
-        showPagination={supervisors.length >= SMALL_TABLE_PAGE_SIZE}
+        showPagination={supervisors.length >= SMALL_TABLE_PAGE_SIZE || page > 0}
         showPageJump={false}
         ofText=""
         columns={[
@@ -1169,6 +1174,7 @@ export class SupervisorsView extends React.PureComponent<
                 visibleColumns: prevState.visibleColumns.toggle(column),
               }))
             }
+            onClose={this.fetchData}
             tableColumnsHidden={visibleColumns.getHiddenColumns()}
           />
         </ViewControlBar>
diff --git a/web-console/src/views/tasks-view/tasks-view.tsx b/web-console/src/views/tasks-view/tasks-view.tsx
index 7dc9b2ab5b00..5972f5ef7ead 100644
--- a/web-console/src/views/tasks-view/tasks-view.tsx
+++ b/web-console/src/views/tasks-view/tasks-view.tsx
@@ -18,7 +18,8 @@
 
 import { Button, ButtonGroup, Intent, Label, MenuItem, Tag } from '@blueprintjs/core';
 import { IconNames } from '@blueprintjs/icons';
-import React from 'react';
+import { formatDistanceToNow } from 'date-fns';
+import React, { type ReactNode } from 'react';
 import type { Filter } from 'react-table';
 import ReactTable from 'react-table';
 
@@ -319,20 +320,26 @@ ORDER BY
     );
   }
 
-  private renderTaskFilterableCell(field: string) {
+  private renderTaskFilterableCell(
+    field: string,
+    enableComparisons = false,
+    valueFn: (value: string) => ReactNode = String,
+  ) {
     const { filters, onFiltersChange } = this.props;
 
-    // eslint-disable-next-line react/display-name
-    return (row: { value: any }) => (
-      <TableFilterableCell
-        field={field}
-        value={row.value}
-        filters={filters}
-        onFiltersChange={onFiltersChange}
-      >
-        {row.value}
-      </TableFilterableCell>
-    );
+    return function TaskFilterableCell(row: { value: any }) {
+      return (
+        <TableFilterableCell
+          field={field}
+          value={row.value}
+          filters={filters}
+          onFiltersChange={onFiltersChange}
+          enableComparisons={enableComparisons}
+        >
+          {valueFn(row.value)}
+        </TableFilterableCell>
+      );
+    };
   }
 
   private onTaskDetail(task: TaskQueryResultRow) {
@@ -473,7 +480,16 @@ ORDER BY
             Header: 'Created time',
             accessor: 'created_time',
             width: 190,
-            Cell: this.renderTaskFilterableCell('created_time'),
+            Cell: this.renderTaskFilterableCell('created_time', true, value => {
+              const valueAsDate = new Date(value);
+              return isNaN(valueAsDate.valueOf()) ? (
+                String(value)
+              ) : (
+                <span data-tooltip={formatDistanceToNow(valueAsDate, { addSuffix: true })}>
+                  {value}
+                </span>
+              );
+            }),
             Aggregated: () => '',
             show: visibleColumns.shown('Created time'),
           },
@@ -486,7 +502,21 @@ ORDER BY
             Cell({ value, original, aggregated }) {
               if (aggregated) return '';
               if (value > 0) {
-                return formatDuration(value);
+                const shownDuration = formatDuration(value);
+
+                const start = new Date(original.created_time);
+                if (isNaN(start.valueOf())) return shownDuration;
+
+                const end = new Date(start.valueOf() + value);
+                return (
+                  <span
+                    data-tooltip={`End time: ${end.toISOString()}\n(${formatDistanceToNow(end, {
+                      addSuffix: true,
+                    })})`}
+                  >
+                    {shownDuration}
+                  </span>
+                );
               }
               if (oneOf(original.status, 'RUNNING', 'PENDING') && original.created_time) {
                 // Compute running duration from the created time if it exists

From 91b21f110d36190941b11e6aa7970a27647637a8 Mon Sep 17 00:00:00 2001
From: Kashif Faraz <kashif.faraz@gmail.com>
Date: Sun, 23 Mar 2025 08:29:49 +0530
Subject: [PATCH 48/99] Use compaction dynamic config to enable compaction
 supervisors (#17782)

Changes
---------
- Remove runtime property object `CompactionSupervisorConfig`
- Add fields `useSupervisors` and `engine` to cluster-level compaction dynamic config
- Remove unused field `useAutoScaleSlots`
---
 .../api-reference/automatic-compaction-api.md | 111 +++++++++++++++++-
 docs/data-management/automatic-compaction.md  |   9 +-
 .../apache/druid/guice/SupervisorModule.java  |   2 -
 .../indexing/compact/CompactionScheduler.java |   8 +-
 .../compact/OverlordCompactionScheduler.java  |  17 ++-
 .../http/OverlordCompactionResource.java      |  10 +-
 .../OverlordCompactionSchedulerTest.java      |  27 ++---
 .../http/OverlordCompactionResourceTest.java  |  31 ++---
 .../utils/DruidClusterAdminClient.java        |   2 +-
 .../clients/CompactionResourceTestClient.java |  21 ++--
 .../utils/DruidClusterAdminClient.java        |   2 +-
 .../ITAutoCompactionLockContentionTest.java   |   2 +-
 .../duty/ITAutoCompactionTest.java            |  37 ++----
 .../compaction/CompactionRunSimulator.java    |   2 +-
 .../coordinator/ClusterCompactionConfig.java  |  72 ++++++++----
 .../CompactionSupervisorConfig.java           |  96 ---------------
 .../coordinator/DruidCompactionConfig.java    | 108 ++++++++---------
 .../CoordinatorCompactionConfigsResource.java |   4 +-
 .../CompactionSupervisorConfigTest.java       |  60 ----------
 ...aSourceCompactionConfigAuditEntryTest.java |  12 +-
 ...DataSourceCompactionConfigHistoryTest.java |   2 +-
 .../DruidCompactionConfigTest.java            |  17 ++-
 .../coordinator/DruidCoordinatorTest.java     |   2 +-
 .../coordinator/duty/CompactSegmentsTest.java |  17 +--
 ...rdinatorCompactionConfigsResourceTest.java |  11 +-
 25 files changed, 312 insertions(+), 370 deletions(-)
 delete mode 100644 server/src/main/java/org/apache/druid/server/coordinator/CompactionSupervisorConfig.java
 delete mode 100644 server/src/test/java/org/apache/druid/server/coordinator/CompactionSupervisorConfigTest.java

diff --git a/docs/api-reference/automatic-compaction-api.md b/docs/api-reference/automatic-compaction-api.md
index 3ad90c9d3391..c09183c09680 100644
--- a/docs/api-reference/automatic-compaction-api.md
+++ b/docs/api-reference/automatic-compaction-api.md
@@ -258,6 +258,102 @@ Host: http://ROUTER_IP:ROUTER_PORT
 
 A successful request returns an HTTP `200 OK` message code and an empty response body.
 
+### Update cluster-level compaction config
+
+Updates cluster-level configuration for compaction tasks which applies to all datasources, unless explicitly overridden in the datasource compaction config.
+This includes the following fields:
+
+|Config|Description|Default value|
+|------|-----------|-------------|
+|`compactionTaskSlotRatio`|Ratio of number of slots taken up by compaction tasks to the number of total task slots across all workers.|0.1|
+|`maxCompactionTaskSlots`|Maximum number of task slots that can be taken up by compaction tasks and sub-tasks. Minimum number of task slots available for compaction is 1. When using MSQ engine or Native engine with range partitioning, a single compaction job occupies more than one task slot. In this case, the minimum is 2 so that at least one compaction job can always run in the cluster.|2147483647 (i.e. total task slots)|
+|`compactionPolicy`|Policy to choose intervals for compaction. Currently, the only supported policy is [Newest segment first](#compaction-policy-newestsegmentfirst).|Newest segment first|
+|`useSupervisors`|Whether compaction should be run on Overlord using supervisors instead of Coordinator duties.|false|
+|`engine`|Engine used for running compaction tasks, unless overridden in the datasource-level compaction config. Possible values are `native` and `msq`. `msq` engine can be used for compaction only if `useSupervisors` is `true`.|`native`|
+
+#### Compaction policy `newestSegmentFirst`
+
+|Field|Description|Default value|
+|-----|-----------|-------------|
+|`type`|This must always be `newestSegmentFirst`||
+|`priorityDatasource`|Datasource to prioritize for compaction. The intervals of this datasource are chosen for compaction before the intervals of any other datasource. Within this datasource, the intervals are prioritized based on the chosen compaction policy.|None|
+
+
+#### URL
+
+`POST` `/druid/coordinator/v1/config/compaction/cluster`
+
+#### Responses
+
+<Tabs>
+
+<TabItem value="8" label="200 SUCCESS">
+
+
+*Successfully updated compaction configuration*
+
+</TabItem>
+<TabItem value="9" label="404 NOT FOUND">
+
+
+*Invalid `max` value*
+
+</TabItem>
+</Tabs>
+
+---
+
+#### Sample request
+
+<Tabs>
+
+<TabItem value="10" label="cURL">
+
+
+```shell
+curl --request POST "http://ROUTER_IP:ROUTER_PORT/druid/coordinator/v1/config/compaction/cluster" \
+--header 'Content-Type: application/json' \
+--data '{
+    "compactionTaskSlotRatio": 0.5,
+    "maxCompactionTaskSlots": 1500,
+    "compactionPolicy": {
+        "type": "newestSegmentFirst",
+        "priorityDatasource": "wikipedia"
+    },
+    "useSupervisors": true,
+    "engine": "msq"
+}'
+
+```
+
+</TabItem>
+<TabItem value="11" label="HTTP">
+
+
+```HTTP
+POST /druid/coordinator/v1/config/compaction/cluster HTTP/1.1
+Host: http://ROUTER_IP:ROUTER_PORT
+Content-Type: application/json
+
+{
+    "compactionTaskSlotRatio": 0.5,
+    "maxCompactionTaskSlots": 1500,
+    "compactionPolicy": {
+        "type": "newestSegmentFirst",
+        "priorityDatasource": "wikipedia"
+    },
+    "useSupervisors": true,
+    "engine": "msq"
+}
+```
+
+</TabItem>
+</Tabs>
+
+#### Sample response
+
+A successful request returns an HTTP `200 OK` message code and an empty response body.
+
 ## View automatic compaction configuration
 
 ### Get all automatic compaction configurations
@@ -406,7 +502,7 @@ Host: http://ROUTER_IP:ROUTER_PORT
     ],
     "compactionTaskSlotRatio": 0.1,
     "maxCompactionTaskSlots": 2147483647,
-    "useAutoScaleSlots": false
+
 }
 ```
 </details>
@@ -593,7 +689,12 @@ Host: http://ROUTER_IP:ROUTER_PORT
         "globalConfig": {
             "compactionTaskSlotRatio": 0.1,
             "maxCompactionTaskSlots": 2147483647,
-            "useAutoScaleSlots": false
+            "compactionPolicy": {
+                "type": "newestSegmentFirst",
+                "priorityDatasource": "wikipedia"
+            },
+            "useSupervisors": true,
+            "engine": "native"
         },
         "compactionConfig": {
             "dataSource": "wikipedia_hour",
@@ -624,7 +725,11 @@ Host: http://ROUTER_IP:ROUTER_PORT
         "globalConfig": {
             "compactionTaskSlotRatio": 0.1,
             "maxCompactionTaskSlots": 2147483647,
-            "useAutoScaleSlots": false
+            "compactionPolicy": {
+                "type": "newestSegmentFirst"
+            },
+            "useSupervisors": false,
+            "engine": "native"
         },
         "compactionConfig": {
             "dataSource": "wikipedia_hour",
diff --git a/docs/data-management/automatic-compaction.md b/docs/data-management/automatic-compaction.md
index 62e209317f81..7d16eae2618c 100644
--- a/docs/data-management/automatic-compaction.md
+++ b/docs/data-management/automatic-compaction.md
@@ -243,11 +243,12 @@ You can run automatic compaction using compaction supervisors on the Overlord ra
 * Tracked compaction task status to avoid re-compacting an interval repeatedly
 
 
-To use compaction supervisors, set the following properties in your Overlord runtime properties:
-  *  `druid.supervisor.compaction.enabled` to `true` so that compaction tasks can be run as supervisor tasks
-  *  `druid.supervisor.compaction.engine` to  `msq` to specify the MSQ task engine as the compaction engine or to `native` to use the native engine. This is the default engine if the `engine` field is omitted from your compaction config
+To use compaction supervisors, update the [compaction dynamic config](../api-reference/automatic-compaction-api.md#update-cluster-level-compaction-config) and set:
 
-Compaction supervisors use the same syntax as auto-compaction using  Coordinator duties with one key difference: you submit the auto-compaction as a a supervisor spec. In the spec, set the `type` to `autocompact` and include the auto-compaction config in the `spec`.
+*  `useSupervisors` to `true` so that compaction tasks can be run as supervisor tasks
+*  `engine` to `msq` to use the MSQ task engine as the compaction engine or to `native` (default value) to use the native engine.
+
+Compaction supervisors use the same syntax as auto-compaction using Coordinator duties with one key difference: you submit the auto-compaction as a supervisor spec. In the spec, set the `type` to `autocompact` and include the auto-compaction config in the `spec`.
 
 To submit an automatic compaction task, you can submit a supervisor spec through the [web console](#manage-compaction-supervisors-with-the-web-console) or the [supervisor API](#manage-compaction-supervisors-with-supervisor-apis).
 
diff --git a/indexing-service/src/main/java/org/apache/druid/guice/SupervisorModule.java b/indexing-service/src/main/java/org/apache/druid/guice/SupervisorModule.java
index 6f510dc562b5..73e8e06e8964 100644
--- a/indexing-service/src/main/java/org/apache/druid/guice/SupervisorModule.java
+++ b/indexing-service/src/main/java/org/apache/druid/guice/SupervisorModule.java
@@ -29,7 +29,6 @@
 import org.apache.druid.indexing.overlord.supervisor.SupervisorStateManagerConfig;
 import org.apache.druid.indexing.scheduledbatch.ScheduledBatchSupervisorSpec;
 import org.apache.druid.initialization.DruidModule;
-import org.apache.druid.server.coordinator.CompactionSupervisorConfig;
 
 import java.util.List;
 
@@ -39,7 +38,6 @@ public class SupervisorModule implements DruidModule
   public void configure(Binder binder)
   {
     JsonConfigProvider.bind(binder, "druid.supervisor", SupervisorStateManagerConfig.class);
-    JsonConfigProvider.bind(binder, "druid.supervisor.compaction", CompactionSupervisorConfig.class);
   }
 
   @Override
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/compact/CompactionScheduler.java b/indexing-service/src/main/java/org/apache/druid/indexing/compact/CompactionScheduler.java
index 83a87b358c91..0df084f362c3 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/compact/CompactionScheduler.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/compact/CompactionScheduler.java
@@ -23,14 +23,14 @@
 import org.apache.druid.server.coordinator.AutoCompactionSnapshot;
 import org.apache.druid.server.coordinator.ClusterCompactionConfig;
 import org.apache.druid.server.coordinator.CompactionConfigValidationResult;
-import org.apache.druid.server.coordinator.CompactionSupervisorConfig;
 import org.apache.druid.server.coordinator.DataSourceCompactionConfig;
+import org.apache.druid.server.coordinator.DruidCompactionConfig;
 
 import java.util.Map;
 
 /**
- * Compaction scheduler that runs on the Overlord if {@link CompactionSupervisorConfig}
- * is enabled.
+ * Compaction scheduler that runs on the Overlord if
+ * {@link DruidCompactionConfig#isUseSupervisors()} is true.
  * <p>
  * Usage:
  * <ul>
@@ -48,6 +48,8 @@ public interface CompactionScheduler
 
   void stop();
 
+  boolean isEnabled();
+
   boolean isRunning();
 
   CompactionConfigValidationResult validateCompactionConfig(DataSourceCompactionConfig compactionConfig);
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/compact/OverlordCompactionScheduler.java b/indexing-service/src/main/java/org/apache/druid/indexing/compact/OverlordCompactionScheduler.java
index 020c0a0ac22c..83a2c5f9f579 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/compact/OverlordCompactionScheduler.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/compact/OverlordCompactionScheduler.java
@@ -44,7 +44,6 @@
 import org.apache.druid.server.coordinator.AutoCompactionSnapshot;
 import org.apache.druid.server.coordinator.ClusterCompactionConfig;
 import org.apache.druid.server.coordinator.CompactionConfigValidationResult;
-import org.apache.druid.server.coordinator.CompactionSupervisorConfig;
 import org.apache.druid.server.coordinator.CoordinatorOverlordServiceConfig;
 import org.apache.druid.server.coordinator.DataSourceCompactionConfig;
 import org.apache.druid.server.coordinator.DruidCompactionConfig;
@@ -66,7 +65,7 @@
 /**
  * Implementation of {@link CompactionScheduler}.
  * <p>
- * When {@link CompactionSupervisorConfig} is enabled, this class performs the
+ * When {@link DruidCompactionConfig#isUseSupervisors()} is true, this class performs the
  * following responsibilities on the leader Overlord:
  * <ul>
  * <li>Poll segments from metadata</li>
@@ -88,7 +87,6 @@ public class OverlordCompactionScheduler implements CompactionScheduler
   private final ServiceEmitter emitter;
   private final TaskMaster taskMaster;
 
-  private final CompactionSupervisorConfig supervisorConfig;
   private final Supplier<DruidCompactionConfig> compactionConfigSupplier;
   private final ConcurrentHashMap<String, DataSourceCompactionConfig> activeDatasourceConfigs;
 
@@ -124,7 +122,6 @@ public OverlordCompactionScheduler(
       SegmentsMetadataManager segmentManager,
       Supplier<DruidCompactionConfig> compactionConfigSupplier,
       CompactionStatusTracker statusTracker,
-      CompactionSupervisorConfig supervisorConfig,
       CoordinatorOverlordServiceConfig coordinatorOverlordServiceConfig,
       ScheduledExecutorFactory executorFactory,
       ServiceEmitter emitter,
@@ -134,7 +131,6 @@ public OverlordCompactionScheduler(
     this.segmentManager = segmentManager;
     this.emitter = emitter;
     this.taskMaster = taskMaster;
-    this.supervisorConfig = supervisorConfig;
     this.compactionConfigSupplier = compactionConfigSupplier;
 
     this.executor = executorFactory.create(1, "CompactionScheduler-%s");
@@ -202,7 +198,7 @@ public CompactionConfigValidationResult validateCompactionConfig(DataSourceCompa
     } else {
       return ClientCompactionRunnerInfo.validateCompactionConfig(
           compactionConfig,
-          supervisorConfig.getEngine()
+          getLatestConfig().getEngine()
       );
     }
   }
@@ -249,9 +245,10 @@ private synchronized void cleanupState()
     }
   }
 
-  private boolean isEnabled()
+  @Override
+  public boolean isEnabled()
   {
-    return supervisorConfig.isEnabled();
+    return compactionConfigSupplier.get().isUseSupervisors();
   }
 
   private synchronized void scheduledRun()
@@ -272,7 +269,7 @@ private synchronized void scheduledRun()
   private synchronized void runCompactionDuty()
   {
     final CoordinatorRunStats stats = new CoordinatorRunStats();
-    duty.run(getLatestConfig(), getDatasourceSnapshot(), supervisorConfig.getEngine(), stats);
+    duty.run(getLatestConfig(), getDatasourceSnapshot(), getLatestConfig().getEngine(), stats);
 
     // Emit stats only if emission period has elapsed
     if (!sinceStatsEmitted.isRunning() || sinceStatsEmitted.hasElapsed(METRIC_EMISSION_PERIOD)) {
@@ -310,7 +307,7 @@ public CompactionSimulateResult simulateRunWithConfigUpdate(ClusterCompactionCon
       return new CompactionRunSimulator(statusTracker, overlordClient).simulateRunWithConfig(
           getLatestConfig().withClusterConfig(updateRequest),
           getDatasourceSnapshot(),
-          supervisorConfig.getEngine()
+          getLatestConfig().getEngine()
       );
     } else {
       return new CompactionSimulateResult(Collections.emptyMap());
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/http/OverlordCompactionResource.java b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/http/OverlordCompactionResource.java
index 425dfc9f35f6..b29cefef83c7 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/http/OverlordCompactionResource.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/http/OverlordCompactionResource.java
@@ -29,7 +29,6 @@
 import org.apache.druid.server.compaction.CompactionStatusResponse;
 import org.apache.druid.server.coordinator.AutoCompactionSnapshot;
 import org.apache.druid.server.coordinator.ClusterCompactionConfig;
-import org.apache.druid.server.coordinator.CompactionSupervisorConfig;
 import org.apache.druid.server.http.ServletResourceUtils;
 import org.apache.druid.server.http.security.StateResourceFilter;
 
@@ -52,16 +51,13 @@
 public class OverlordCompactionResource
 {
   private final CompactionScheduler scheduler;
-  private final CompactionSupervisorConfig supervisorConfig;
 
   @Inject
   public OverlordCompactionResource(
-      CompactionSupervisorConfig supervisorConfig,
       CompactionScheduler scheduler
   )
   {
     this.scheduler = scheduler;
-    this.supervisorConfig = supervisorConfig;
   }
 
   @GET
@@ -70,7 +66,7 @@ public OverlordCompactionResource(
   @ResourceFilters(StateResourceFilter.class)
   public Response isCompactionSupervisorEnabled()
   {
-    return Response.ok(supervisorConfig.isEnabled()).build();
+    return Response.ok(scheduler.isEnabled()).build();
   }
 
   @GET
@@ -81,7 +77,7 @@ public Response getCompactionProgress(
       @QueryParam("dataSource") String dataSource
   )
   {
-    if (!supervisorConfig.isEnabled()) {
+    if (!scheduler.isEnabled()) {
       return buildErrorResponseIfSchedulerDisabled();
     }
 
@@ -106,7 +102,7 @@ public Response getCompactionSnapshots(
       @QueryParam("dataSource") String dataSource
   )
   {
-    if (!supervisorConfig.isEnabled()) {
+    if (!scheduler.isEnabled()) {
       return buildErrorResponseIfSchedulerDisabled();
     }
 
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/compact/OverlordCompactionSchedulerTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/compact/OverlordCompactionSchedulerTest.java
index 2805b05cc6f5..c627a0a4d786 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/compact/OverlordCompactionSchedulerTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/compact/OverlordCompactionSchedulerTest.java
@@ -51,7 +51,6 @@
 import org.apache.druid.server.coordinator.AutoCompactionSnapshot;
 import org.apache.druid.server.coordinator.ClusterCompactionConfig;
 import org.apache.druid.server.coordinator.CompactionConfigValidationResult;
-import org.apache.druid.server.coordinator.CompactionSupervisorConfig;
 import org.apache.druid.server.coordinator.CoordinatorOverlordServiceConfig;
 import org.apache.druid.server.coordinator.CreateDataSegments;
 import org.apache.druid.server.coordinator.DataSourceCompactionConfig;
@@ -90,7 +89,6 @@ public class OverlordCompactionSchedulerTest
     );
   }
 
-  private CompactionSupervisorConfig supervisorConfig;
   private DruidCompactionConfig compactionConfig;
   private CoordinatorOverlordServiceConfig coordinatorOverlordServiceConfig;
 
@@ -128,14 +126,13 @@ public void setUp()
     serviceEmitter = new StubServiceEmitter();
     segmentsMetadataManager = new TestSegmentsMetadataManager();
 
-    supervisorConfig = new CompactionSupervisorConfig(true, null);
     compactionConfig = DruidCompactionConfig.empty();
     coordinatorOverlordServiceConfig = new CoordinatorOverlordServiceConfig(false, null);
 
-    initScheduler();
+    initScheduler(true);
   }
 
-  private void initScheduler()
+  private void initScheduler(boolean isSupervisorEnabled)
   {
     TaskLockbox taskLockbox = new TaskLockbox(taskStorage, new TestIndexerMetadataStorageCoordinator());
     WorkerBehaviorConfig defaultWorkerConfig
@@ -144,9 +141,10 @@ private void initScheduler()
         taskMaster,
         new TaskQueryTool(taskStorage, taskLockbox, taskMaster, null, () -> defaultWorkerConfig),
         segmentsMetadataManager,
-        () -> compactionConfig,
+        () -> compactionConfig.withClusterConfig(
+            new ClusterCompactionConfig(null, null, null, isSupervisorEnabled, null)
+        ),
         new CompactionStatusTracker(OBJECT_MAPPER),
-        supervisorConfig,
         coordinatorOverlordServiceConfig,
         (nameFormat, numThreads) -> new WrappingScheduledExecutorService("test", executor, false),
         serviceEmitter,
@@ -157,7 +155,6 @@ private void initScheduler()
   @Test
   public void testStartStopWhenSchedulerIsEnabled()
   {
-    supervisorConfig = new CompactionSupervisorConfig(true, null);
     Assert.assertFalse(scheduler.isRunning());
 
     scheduler.start();
@@ -176,8 +173,7 @@ public void testStartStopWhenSchedulerIsEnabled()
   @Test
   public void testStartStopWhenScheduledIsDisabled()
   {
-    supervisorConfig = new CompactionSupervisorConfig(false, null);
-    initScheduler();
+    initScheduler(false);
 
     Assert.assertFalse(scheduler.isRunning());
     scheduler.start();
@@ -191,8 +187,7 @@ public void testStartStopWhenScheduledIsDisabled()
   @Test
   public void testSegmentsAreNotPolledWhenSchedulerIsDisabled()
   {
-    supervisorConfig = new CompactionSupervisorConfig(false, null);
-    initScheduler();
+    initScheduler(false);
 
     verifySegmentPolling(false);
   }
@@ -201,7 +196,7 @@ public void testSegmentsAreNotPolledWhenSchedulerIsDisabled()
   public void testSegmentsArePolledWhenRunningInStandaloneMode()
   {
     coordinatorOverlordServiceConfig = new CoordinatorOverlordServiceConfig(false, null);
-    initScheduler();
+    initScheduler(true);
 
     verifySegmentPolling(true);
   }
@@ -210,7 +205,7 @@ public void testSegmentsArePolledWhenRunningInStandaloneMode()
   public void testSegmentsAreNotPolledWhenRunningInCoordinatorMode()
   {
     coordinatorOverlordServiceConfig = new CoordinatorOverlordServiceConfig(true, "overlord");
-    initScheduler();
+    initScheduler(true);
 
     verifySegmentPolling(false);
   }
@@ -345,7 +340,7 @@ public void testRunSimulation()
     );
 
     final CompactionSimulateResult simulateResult = scheduler.simulateRunWithConfigUpdate(
-        new ClusterCompactionConfig(null, null, null, null)
+        new ClusterCompactionConfig(null, null, null, null, null)
     );
     Assert.assertEquals(1, simulateResult.getCompactionStates().size());
     final Table pendingCompactionTable = simulateResult.getCompactionStates().get(CompactionStatus.State.PENDING);
@@ -370,7 +365,7 @@ public void testRunSimulation()
     scheduler.stopCompaction(TestDataSource.WIKI);
 
     final CompactionSimulateResult simulateResultWhenDisabled = scheduler.simulateRunWithConfigUpdate(
-        new ClusterCompactionConfig(null, null, null, null)
+        new ClusterCompactionConfig(null, null, null, null, null)
     );
     Assert.assertTrue(simulateResultWhenDisabled.getCompactionStates().isEmpty());
 
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordCompactionResourceTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordCompactionResourceTest.java
index d0aba195c423..de9cd7ec6c06 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordCompactionResourceTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordCompactionResourceTest.java
@@ -29,7 +29,6 @@
 import org.apache.druid.server.compaction.CompactionStatistics;
 import org.apache.druid.server.compaction.CompactionStatusResponse;
 import org.apache.druid.server.coordinator.AutoCompactionSnapshot;
-import org.apache.druid.server.coordinator.CompactionSupervisorConfig;
 import org.easymock.EasyMock;
 import org.hamcrest.MatcherAssert;
 import org.junit.After;
@@ -43,17 +42,13 @@
 
 public class OverlordCompactionResourceTest
 {
-  private static final CompactionSupervisorConfig SUPERVISOR_ENABLED
-      = new CompactionSupervisorConfig(true, null);
-  private static final CompactionSupervisorConfig SUPERVISOR_DISABLED
-      = new CompactionSupervisorConfig(false, null);
-
   private CompactionScheduler scheduler;
 
   @Before
   public void setUp()
   {
     scheduler = EasyMock.createStrictMock(CompactionScheduler.class);
+    EasyMock.expect(scheduler.isEnabled()).andReturn(true).anyTimes();
   }
 
   @After
@@ -74,7 +69,7 @@ public void testGetCompactionSnapshotWithEmptyDatasource()
             .andReturn(allSnapshots).once();
     EasyMock.replay(scheduler);
 
-    final Response response = new OverlordCompactionResource(SUPERVISOR_ENABLED, scheduler)
+    final Response response = new OverlordCompactionResource(scheduler)
         .getCompactionSnapshots("");
     Assert.assertEquals(200, response.getStatus());
     Assert.assertEquals(
@@ -95,7 +90,7 @@ public void testGetCompactionSnapshotWithNullDatasource()
             .andReturn(allSnapshots).once();
     EasyMock.replay(scheduler);
 
-    final Response response = new OverlordCompactionResource(SUPERVISOR_ENABLED, scheduler)
+    final Response response = new OverlordCompactionResource(scheduler)
         .getCompactionSnapshots(null);
     Assert.assertEquals(200, response.getStatus());
     Assert.assertEquals(
@@ -113,7 +108,7 @@ public void testGetCompactionSnapshotWithValidDatasource()
             .andReturn(snapshot).once();
     EasyMock.replay(scheduler);
 
-    final Response response = new OverlordCompactionResource(SUPERVISOR_ENABLED, scheduler)
+    final Response response = new OverlordCompactionResource(scheduler)
         .getCompactionSnapshots(TestDataSource.WIKI);
     Assert.assertEquals(200, response.getStatus());
     Assert.assertEquals(
@@ -129,7 +124,7 @@ public void testGetCompactionSnapshotWithInvalidDatasource()
             .andReturn(null).once();
     EasyMock.replay(scheduler);
 
-    final Response response = new OverlordCompactionResource(SUPERVISOR_ENABLED, scheduler)
+    final Response response = new OverlordCompactionResource(scheduler)
         .getCompactionSnapshots(TestDataSource.KOALA);
     Assert.assertEquals(404, response.getStatus());
   }
@@ -146,7 +141,7 @@ public void testGetProgressForValidDatasource()
             .andReturn(snapshot).once();
     EasyMock.replay(scheduler);
 
-    final Response response = new OverlordCompactionResource(SUPERVISOR_ENABLED, scheduler)
+    final Response response = new OverlordCompactionResource(scheduler)
         .getCompactionProgress(TestDataSource.WIKI);
     Assert.assertEquals(200, response.getStatus());
     Assert.assertEquals(new CompactionProgressResponse(100L), response.getEntity());
@@ -157,7 +152,7 @@ public void testGetProgressForNullDatasourceReturnsBadRequest()
   {
     EasyMock.replay(scheduler);
 
-    final Response response = new OverlordCompactionResource(SUPERVISOR_ENABLED, scheduler)
+    final Response response = new OverlordCompactionResource(scheduler)
         .getCompactionProgress(null);
     Assert.assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
 
@@ -177,7 +172,7 @@ public void testGetProgressForInvalidDatasourceReturnsNotFound()
             .andReturn(null).once();
     EasyMock.replay(scheduler);
 
-    final Response response = new OverlordCompactionResource(SUPERVISOR_ENABLED, scheduler)
+    final Response response = new OverlordCompactionResource(scheduler)
         .getCompactionProgress(TestDataSource.KOALA);
     Assert.assertEquals(Response.Status.NOT_FOUND.getStatusCode(), response.getStatus());
 
@@ -193,9 +188,12 @@ public void testGetProgressForInvalidDatasourceReturnsNotFound()
   @Test
   public void testGetProgressReturnsUnsupportedWhenSupervisorDisabled()
   {
+    scheduler = EasyMock.createStrictMock(CompactionScheduler.class);
+    EasyMock.expect(scheduler.isEnabled()).andReturn(false).once();
     EasyMock.replay(scheduler);
+
     verifyResponseWhenSupervisorDisabled(
-        new OverlordCompactionResource(SUPERVISOR_DISABLED, scheduler)
+        new OverlordCompactionResource(scheduler)
             .getCompactionProgress(TestDataSource.WIKI)
     );
   }
@@ -203,9 +201,12 @@ public void testGetProgressReturnsUnsupportedWhenSupervisorDisabled()
   @Test
   public void testGetSnapshotReturnsUnsupportedWhenSupervisorDisabled()
   {
+    scheduler = EasyMock.createStrictMock(CompactionScheduler.class);
+    EasyMock.expect(scheduler.isEnabled()).andReturn(false).once();
     EasyMock.replay(scheduler);
+
     verifyResponseWhenSupervisorDisabled(
-        new OverlordCompactionResource(SUPERVISOR_DISABLED, scheduler)
+        new OverlordCompactionResource(scheduler)
             .getCompactionSnapshots(TestDataSource.WIKI)
     );
   }
diff --git a/integration-tests-ex/cases/src/test/java/org/apache/druid/testsEx/utils/DruidClusterAdminClient.java b/integration-tests-ex/cases/src/test/java/org/apache/druid/testsEx/utils/DruidClusterAdminClient.java
index 9c15eef30c5f..48b7e4b6236b 100644
--- a/integration-tests-ex/cases/src/test/java/org/apache/druid/testsEx/utils/DruidClusterAdminClient.java
+++ b/integration-tests-ex/cases/src/test/java/org/apache/druid/testsEx/utils/DruidClusterAdminClient.java
@@ -215,7 +215,7 @@ public Pair<String, String> runCommandInDockerContainer(String serviceName, Stri
                 .exec(new ExecStartResultCallback(stdout, stderr))
                 .awaitCompletion();
 
-    return new Pair<>(stdout.toString(StandardCharsets.UTF_8.name()), stderr.toString(StandardCharsets.UTF_8.name()));
+    return new Pair<>(stdout.toString(StandardCharsets.UTF_8), stderr.toString(StandardCharsets.UTF_8));
   }
 
   public void restartDockerContainer(String serviceName)
diff --git a/integration-tests/src/main/java/org/apache/druid/testing/clients/CompactionResourceTestClient.java b/integration-tests/src/main/java/org/apache/druid/testing/clients/CompactionResourceTestClient.java
index 849af4975673..da0b2f3516d0 100644
--- a/integration-tests/src/main/java/org/apache/druid/testing/clients/CompactionResourceTestClient.java
+++ b/integration-tests/src/main/java/org/apache/druid/testing/clients/CompactionResourceTestClient.java
@@ -145,21 +145,14 @@ public void forceTriggerAutoCompaction() throws Exception
     }
   }
 
-  public void updateCompactionTaskSlot(Double compactionTaskSlotRatio, Integer maxCompactionTaskSlots, Boolean useAutoScaleSlots) throws Exception
+  public void updateCompactionTaskSlot(Double compactionTaskSlotRatio, Integer maxCompactionTaskSlots) throws Exception
   {
-    String url;
-    if (useAutoScaleSlots == null) {
-      url = StringUtils.format("%sconfig/compaction/taskslots?ratio=%s&max=%s",
-                                      getCoordinatorURL(),
-                                      StringUtils.urlEncode(compactionTaskSlotRatio.toString()),
-                                      StringUtils.urlEncode(maxCompactionTaskSlots.toString()));
-    } else {
-      url = StringUtils.format("%sconfig/compaction/taskslots?ratio=%s&max=%s&useAutoScaleSlots=%s",
-                                      getCoordinatorURL(),
-                                      StringUtils.urlEncode(compactionTaskSlotRatio.toString()),
-                                      StringUtils.urlEncode(maxCompactionTaskSlots.toString()),
-                                      StringUtils.urlEncode(useAutoScaleSlots.toString()));
-    }
+    String url = StringUtils.format(
+        "%sconfig/compaction/taskslots?ratio=%s&max=%s",
+        getCoordinatorURL(),
+        StringUtils.urlEncode(compactionTaskSlotRatio.toString()),
+        StringUtils.urlEncode(maxCompactionTaskSlots.toString())
+    );
     StatusResponseHolder response = httpClient.go(new Request(HttpMethod.POST, new URL(url)), responseHandler).get();
     if (!response.getStatus().equals(HttpResponseStatus.OK)) {
       throw new ISE(
diff --git a/integration-tests/src/main/java/org/apache/druid/testing/utils/DruidClusterAdminClient.java b/integration-tests/src/main/java/org/apache/druid/testing/utils/DruidClusterAdminClient.java
index 6b98306ca0e6..bc65fb3d8db3 100644
--- a/integration-tests/src/main/java/org/apache/druid/testing/utils/DruidClusterAdminClient.java
+++ b/integration-tests/src/main/java/org/apache/druid/testing/utils/DruidClusterAdminClient.java
@@ -214,7 +214,7 @@ public Pair<String, String> runCommandInDockerContainer(String serviceName, Stri
                 .exec(new ExecStartResultCallback(stdout, stderr))
                 .awaitCompletion();
 
-    return new Pair<>(stdout.toString(StandardCharsets.UTF_8.name()), stderr.toString(StandardCharsets.UTF_8.name()));
+    return new Pair<>(stdout.toString(StandardCharsets.UTF_8), stderr.toString(StandardCharsets.UTF_8));
   }
 
   public void restartDockerContainer(String serviceName)
diff --git a/integration-tests/src/test/java/org/apache/druid/tests/coordinator/duty/ITAutoCompactionLockContentionTest.java b/integration-tests/src/test/java/org/apache/druid/tests/coordinator/duty/ITAutoCompactionLockContentionTest.java
index 0a1071c38e71..a5943aacb336 100644
--- a/integration-tests/src/test/java/org/apache/druid/tests/coordinator/duty/ITAutoCompactionLockContentionTest.java
+++ b/integration-tests/src/test/java/org/apache/druid/tests/coordinator/duty/ITAutoCompactionLockContentionTest.java
@@ -310,7 +310,7 @@ private void submitAndVerifyCompactionConfig() throws Exception
         .withSkipOffsetFromLatest(Period.ZERO)
         .withMaxRowsPerSegment(Specs.MAX_ROWS_PER_SEGMENT)
         .build();
-    compactionResource.updateCompactionTaskSlot(0.5, 10, null);
+    compactionResource.updateCompactionTaskSlot(0.5, 10);
     compactionResource.submitCompactionConfig(dataSourceCompactionConfig);
 
     // Wait for compaction config to persist
diff --git a/integration-tests/src/test/java/org/apache/druid/tests/coordinator/duty/ITAutoCompactionTest.java b/integration-tests/src/test/java/org/apache/druid/tests/coordinator/duty/ITAutoCompactionTest.java
index baf7177b373d..e993dafdbcfd 100644
--- a/integration-tests/src/test/java/org/apache/druid/tests/coordinator/duty/ITAutoCompactionTest.java
+++ b/integration-tests/src/test/java/org/apache/druid/tests/coordinator/duty/ITAutoCompactionTest.java
@@ -133,7 +133,7 @@ public static Object[][] engine()
   public void setup() throws Exception
   {
     // Set compaction slot to 5
-    updateCompactionTaskSlot(0.5, 10, null);
+    updateCompactionTaskSlot(0.5, 10);
     fullDatasourceName = "wikipedia_index_test_" + UUID.randomUUID() + config.getExtraDatasourceNameSuffix();
   }
 
@@ -410,7 +410,7 @@ public void testAutoCompactionWithMetricColumnSameAsInputColShouldOverwriteInput
     // added = 31
     loadData(INDEX_TASK_WITHOUT_ROLLUP_FOR_PRESERVE_METRICS);
     if (engine == CompactionEngine.MSQ) {
-      updateCompactionTaskSlot(0.1, 2, false);
+      updateCompactionTaskSlot(0.1, 2);
     }
     try (final Closeable ignored = unloader(fullDatasourceName)) {
       final List<String> intervalsBeforeCompaction = coordinator.getSegmentIntervals(fullDatasourceName);
@@ -744,7 +744,7 @@ public void testAutoCompactionDutyCanDeleteCompactionConfig(CompactionEngine eng
   public void testAutoCompactionDutyCanUpdateTaskSlots() throws Exception
   {
     // Set compactionTaskSlotRatio to 0 to prevent any compaction
-    updateCompactionTaskSlot(0, 0, null);
+    updateCompactionTaskSlot(0, 0);
     loadData(INDEX_TASK);
     try (final Closeable ignored = unloader(fullDatasourceName)) {
       final List<String> intervalsBeforeCompaction = coordinator.getSegmentIntervals(fullDatasourceName);
@@ -761,7 +761,7 @@ public void testAutoCompactionDutyCanUpdateTaskSlots() throws Exception
       checkCompactionIntervals(intervalsBeforeCompaction);
       Assert.assertNull(compactionResource.getCompactionStatus(fullDatasourceName));
       // Update compaction slots to be 1
-      updateCompactionTaskSlot(1, 1, null);
+      updateCompactionTaskSlot(1, 1);
       // One day compacted (1 new segment) and one day remains uncompacted. (3 total)
       forceTriggerAutoCompaction(3);
       verifyQuery(INDEX_QUERIES_RESOURCE);
@@ -1365,7 +1365,7 @@ public void testAutoCompactionDutyWithSegmentGranularityAndSmallerSegmentGranula
   @Test
   public void testAutoCompactionDutyWithSegmentGranularityFinerAndNotAlignWithSegment() throws Exception
   {
-    updateCompactionTaskSlot(1, 1, null);
+    updateCompactionTaskSlot(1, 1);
     final ISOChronology chrono = ISOChronology.getInstance(DateTimes.inferTzFromString("America/Los_Angeles"));
     Map<String, Object> specs = ImmutableMap.of("%%GRANULARITYSPEC%%", new UniformGranularitySpec(Granularities.MONTH, Granularities.DAY, false, ImmutableList.of(new Interval("2013-08-31/2013-09-02", chrono))));
     loadData(INDEX_TASK_WITH_GRANULARITY_SPEC, specs);
@@ -1416,7 +1416,7 @@ public void testAutoCompactionDutyWithSegmentGranularityFinerAndNotAlignWithSegm
   @Test(dataProvider = "engine")
   public void testAutoCompactionDutyWithSegmentGranularityCoarserAndNotAlignWithSegment(CompactionEngine engine) throws Exception
   {
-    updateCompactionTaskSlot(1, 1, null);
+    updateCompactionTaskSlot(1, 1);
     final ISOChronology chrono = ISOChronology.getInstance(DateTimes.inferTzFromString("America/Los_Angeles"));
     Map<String, Object> specs = ImmutableMap.of("%%GRANULARITYSPEC%%", new UniformGranularitySpec(Granularities.WEEK, Granularities.DAY, false, ImmutableList.of(new Interval("2013-08-31/2013-09-02", chrono))));
     loadData(INDEX_TASK_WITH_GRANULARITY_SPEC, specs);
@@ -1745,24 +1745,6 @@ public void testAutoCompactionDutyWithOverlappingInterval() throws Exception
     }
   }
 
-  @Test
-  public void testUpdateCompactionTaskSlotWithUseAutoScaleSlots() throws Exception
-  {
-    // First try update without useAutoScaleSlots
-    updateCompactionTaskSlot(3, 5, null);
-    DruidCompactionConfig compactionConfig = compactionResource.getCompactionConfig();
-    // Should be default value which is false
-    Assert.assertFalse(compactionConfig.isUseAutoScaleSlots());
-    // Now try update from default value to useAutoScaleSlots=true
-    updateCompactionTaskSlot(3, 5, true);
-    compactionConfig = compactionResource.getCompactionConfig();
-    Assert.assertTrue(compactionConfig.isUseAutoScaleSlots());
-    // Now try update from useAutoScaleSlots=true to useAutoScaleSlots=false
-    updateCompactionTaskSlot(3, 5, false);
-    compactionConfig = compactionResource.getCompactionConfig();
-    Assert.assertFalse(compactionConfig.isUseAutoScaleSlots());
-  }
-
   private void loadData(String indexTask) throws Exception
   {
     loadData(indexTask, ImmutableMap.of());
@@ -2062,16 +2044,13 @@ private void verifySegmentsCompactedDimensionSchema(List<DimensionSchema> dimens
     }
   }
 
-  private void updateCompactionTaskSlot(double compactionTaskSlotRatio, int maxCompactionTaskSlots, Boolean useAutoScaleSlots) throws Exception
+  private void updateCompactionTaskSlot(double compactionTaskSlotRatio, int maxCompactionTaskSlots) throws Exception
   {
-    compactionResource.updateCompactionTaskSlot(compactionTaskSlotRatio, maxCompactionTaskSlots, useAutoScaleSlots);
+    compactionResource.updateCompactionTaskSlot(compactionTaskSlotRatio, maxCompactionTaskSlots);
     // Verify that the compaction config is updated correctly.
     DruidCompactionConfig compactionConfig = compactionResource.getCompactionConfig();
     Assert.assertEquals(compactionConfig.getCompactionTaskSlotRatio(), compactionTaskSlotRatio);
     Assert.assertEquals(compactionConfig.getMaxCompactionTaskSlots(), maxCompactionTaskSlots);
-    if (useAutoScaleSlots != null) {
-      Assert.assertEquals(compactionConfig.isUseAutoScaleSlots(), useAutoScaleSlots.booleanValue());
-    }
   }
 
   private void getAndAssertCompactionStatus(
diff --git a/server/src/main/java/org/apache/druid/server/compaction/CompactionRunSimulator.java b/server/src/main/java/org/apache/druid/server/compaction/CompactionRunSimulator.java
index b74735e6aa3a..646319eec3b2 100644
--- a/server/src/main/java/org/apache/druid/server/compaction/CompactionRunSimulator.java
+++ b/server/src/main/java/org/apache/druid/server/compaction/CompactionRunSimulator.java
@@ -135,7 +135,7 @@ public void onTaskSubmitted(ClientCompactionTaskQuery taskPayload, CompactionCan
 
     // Unlimited task slots to ensure that simulator does not skip any interval
     final DruidCompactionConfig configWithUnlimitedTaskSlots = compactionConfig.withClusterConfig(
-        new ClusterCompactionConfig(1.0, Integer.MAX_VALUE, null, null)
+        new ClusterCompactionConfig(1.0, Integer.MAX_VALUE, null, null, null)
     );
 
     final CoordinatorRunStats stats = new CoordinatorRunStats();
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/ClusterCompactionConfig.java b/server/src/main/java/org/apache/druid/server/coordinator/ClusterCompactionConfig.java
index 2e0c070b1ed2..7334251da76c 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/ClusterCompactionConfig.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/ClusterCompactionConfig.java
@@ -21,7 +21,11 @@
 
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
+import org.apache.druid.common.config.Configs;
+import org.apache.druid.error.InvalidInput;
+import org.apache.druid.indexer.CompactionEngine;
 import org.apache.druid.server.compaction.CompactionCandidateSearchPolicy;
+import org.apache.druid.server.compaction.NewestSegmentFirstPolicy;
 
 import javax.annotation.Nullable;
 import java.util.Objects;
@@ -33,51 +37,63 @@
  */
 public class ClusterCompactionConfig
 {
+  private static final CompactionCandidateSearchPolicy DEFAULT_COMPACTION_POLICY
+      = new NewestSegmentFirstPolicy(null);
+
   private final Double compactionTaskSlotRatio;
   private final Integer maxCompactionTaskSlots;
-  private final Boolean useAutoScaleSlots;
+  private final Boolean useSupervisors;
+  private final CompactionEngine engine;
   private final CompactionCandidateSearchPolicy compactionPolicy;
 
   @JsonCreator
   public ClusterCompactionConfig(
       @JsonProperty("compactionTaskSlotRatio") @Nullable Double compactionTaskSlotRatio,
       @JsonProperty("maxCompactionTaskSlots") @Nullable Integer maxCompactionTaskSlots,
-      @JsonProperty("useAutoScaleSlots") @Nullable Boolean useAutoScaleSlots,
-      @JsonProperty("compactionPolicy") @Nullable CompactionCandidateSearchPolicy compactionPolicy
+      @JsonProperty("compactionPolicy") @Nullable CompactionCandidateSearchPolicy compactionPolicy,
+      @JsonProperty("useSupervisors") @Nullable Boolean useSupervisors,
+      @JsonProperty("engine") @Nullable CompactionEngine engine
   )
   {
-    this.compactionTaskSlotRatio = compactionTaskSlotRatio;
-    this.maxCompactionTaskSlots = maxCompactionTaskSlots;
-    this.useAutoScaleSlots = useAutoScaleSlots;
-    this.compactionPolicy = compactionPolicy;
+    this.compactionTaskSlotRatio = Configs.valueOrDefault(compactionTaskSlotRatio, 0.1);
+    this.maxCompactionTaskSlots = Configs.valueOrDefault(maxCompactionTaskSlots, Integer.MAX_VALUE);
+    this.compactionPolicy = Configs.valueOrDefault(compactionPolicy, DEFAULT_COMPACTION_POLICY);
+    this.engine = Configs.valueOrDefault(engine, CompactionEngine.NATIVE);
+    this.useSupervisors = Configs.valueOrDefault(useSupervisors, false);
+
+    if (!this.useSupervisors && this.engine == CompactionEngine.MSQ) {
+      throw InvalidInput.exception("MSQ Compaction engine can be used only with compaction supervisors.");
+    }
   }
 
-  @Nullable
   @JsonProperty
-  public Double getCompactionTaskSlotRatio()
+  public double getCompactionTaskSlotRatio()
   {
     return compactionTaskSlotRatio;
   }
 
-  @Nullable
   @JsonProperty
-  public Integer getMaxCompactionTaskSlots()
+  public int getMaxCompactionTaskSlots()
   {
     return maxCompactionTaskSlots;
   }
 
-  @Nullable
   @JsonProperty
-  public Boolean getUseAutoScaleSlots()
+  public CompactionCandidateSearchPolicy getCompactionPolicy()
   {
-    return useAutoScaleSlots;
+    return compactionPolicy;
   }
 
-  @Nullable
   @JsonProperty
-  public CompactionCandidateSearchPolicy getCompactionPolicy()
+  public boolean getUseSupervisors()
   {
-    return compactionPolicy;
+    return useSupervisors;
+  }
+
+  @JsonProperty
+  public CompactionEngine getEngine()
+  {
+    return engine;
   }
 
   @Override
@@ -92,8 +108,9 @@ public boolean equals(Object o)
     ClusterCompactionConfig that = (ClusterCompactionConfig) o;
     return Objects.equals(compactionTaskSlotRatio, that.compactionTaskSlotRatio)
            && Objects.equals(maxCompactionTaskSlots, that.maxCompactionTaskSlots)
-           && Objects.equals(useAutoScaleSlots, that.useAutoScaleSlots)
-           && Objects.equals(compactionPolicy, that.compactionPolicy);
+           && Objects.equals(compactionPolicy, that.compactionPolicy)
+           && Objects.equals(useSupervisors, that.useSupervisors)
+           && Objects.equals(engine, that.engine);
   }
 
   @Override
@@ -102,8 +119,21 @@ public int hashCode()
     return Objects.hash(
         compactionTaskSlotRatio,
         maxCompactionTaskSlots,
-        useAutoScaleSlots,
-        compactionPolicy
+        compactionPolicy,
+        useSupervisors,
+        engine
     );
   }
+
+  @Override
+  public String toString()
+  {
+    return "ClusterCompactionConfig{" +
+           "compactionTaskSlotRatio=" + compactionTaskSlotRatio +
+           ", maxCompactionTaskSlots=" + maxCompactionTaskSlots +
+           ", useSupervisors=" + useSupervisors +
+           ", engine=" + engine +
+           ", compactionPolicy=" + compactionPolicy +
+           '}';
+  }
 }
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/CompactionSupervisorConfig.java b/server/src/main/java/org/apache/druid/server/coordinator/CompactionSupervisorConfig.java
deleted file mode 100644
index 2cc2f0d133f7..000000000000
--- a/server/src/main/java/org/apache/druid/server/coordinator/CompactionSupervisorConfig.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.apache.druid.server.coordinator;
-
-import com.fasterxml.jackson.annotation.JsonCreator;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import org.apache.druid.common.config.Configs;
-import org.apache.druid.indexer.CompactionEngine;
-
-import javax.annotation.Nullable;
-import java.util.Objects;
-
-/**
- * This config must be bound on CliOverlord to enable running compaction supervisors
- * on the Overlord. When compaction supervisors are enabled, the Coordinator
- * does not run auto-compact duty.
- */
-public class CompactionSupervisorConfig
-{
-  private static final CompactionSupervisorConfig DEFAULT = new CompactionSupervisorConfig(null, null);
-
-  @JsonProperty
-  private final boolean enabled;
-  @JsonProperty
-  private final CompactionEngine engine;
-
-  public static CompactionSupervisorConfig defaultConfig()
-  {
-    return DEFAULT;
-  }
-
-  @JsonCreator
-  public CompactionSupervisorConfig(
-      @JsonProperty("enabled") @Nullable Boolean enabled,
-      @JsonProperty("engine") @Nullable CompactionEngine engine
-  )
-  {
-    this.enabled = Configs.valueOrDefault(enabled, false);
-    this.engine = Configs.valueOrDefault(engine, CompactionEngine.NATIVE);
-  }
-
-  public boolean isEnabled()
-  {
-    return enabled;
-  }
-
-  public CompactionEngine getEngine()
-  {
-    return engine;
-  }
-
-  @Override
-  public boolean equals(Object o)
-  {
-    if (this == o) {
-      return true;
-    }
-    if (o == null || getClass() != o.getClass()) {
-      return false;
-    }
-    CompactionSupervisorConfig that = (CompactionSupervisorConfig) o;
-    return enabled == that.enabled && engine == that.engine;
-  }
-
-  @Override
-  public int hashCode()
-  {
-    return Objects.hash(enabled, engine);
-  }
-
-  @Override
-  public String toString()
-  {
-    return "CompactionSchedulerConfig{" +
-           "enabled=" + enabled +
-           "engine=" + engine +
-           '}';
-  }
-}
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/DruidCompactionConfig.java b/server/src/main/java/org/apache/druid/server/coordinator/DruidCompactionConfig.java
index 96338f5b2ef6..d9298c6ab637 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/DruidCompactionConfig.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/DruidCompactionConfig.java
@@ -23,8 +23,8 @@
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.base.Optional;
 import org.apache.druid.common.config.Configs;
+import org.apache.druid.indexer.CompactionEngine;
 import org.apache.druid.server.compaction.CompactionCandidateSearchPolicy;
-import org.apache.druid.server.compaction.NewestSegmentFirstPolicy;
 
 import javax.annotation.Nullable;
 import java.util.ArrayList;
@@ -39,41 +39,32 @@ public class DruidCompactionConfig
 {
   public static final String CONFIG_KEY = "coordinator.compaction.config";
 
-  private static final CompactionCandidateSearchPolicy DEFAULT_COMPACTION_POLICY
-      = new NewestSegmentFirstPolicy(null);
   private static final DruidCompactionConfig EMPTY_INSTANCE
-      = new DruidCompactionConfig(Collections.emptyList(), null, null, null, null);
+      = new DruidCompactionConfig(List.of(), null, null, null, null, null);
 
   private final List<DataSourceCompactionConfig> compactionConfigs;
-  private final double compactionTaskSlotRatio;
-  private final int maxCompactionTaskSlots;
-  private final boolean useAutoScaleSlots;
-  private final CompactionCandidateSearchPolicy compactionPolicy;
+  private final ClusterCompactionConfig clusterConfig;
 
+  /**
+   * Creates a copy of this {@link DruidCompactionConfig} with the given
+   * datasource compaction configs.
+   */
   public DruidCompactionConfig withDatasourceConfigs(
       List<DataSourceCompactionConfig> compactionConfigs
   )
   {
-    return new DruidCompactionConfig(
-        compactionConfigs,
-        compactionTaskSlotRatio,
-        maxCompactionTaskSlots,
-        useAutoScaleSlots,
-        compactionPolicy
-    );
+    return new DruidCompactionConfig(compactionConfigs, clusterConfig);
   }
 
+  /**
+   * Creates a copy of this {@link DruidCompactionConfig} by updating the
+   * fields provided in the {@link ClusterCompactionConfig}.
+   */
   public DruidCompactionConfig withClusterConfig(
-      ClusterCompactionConfig update
+      ClusterCompactionConfig clusterConfig
   )
   {
-    return new DruidCompactionConfig(
-        this.compactionConfigs,
-        Configs.valueOrDefault(update.getCompactionTaskSlotRatio(), compactionTaskSlotRatio),
-        Configs.valueOrDefault(update.getMaxCompactionTaskSlots(), maxCompactionTaskSlots),
-        Configs.valueOrDefault(update.getUseAutoScaleSlots(), useAutoScaleSlots),
-        Configs.valueOrDefault(update.getCompactionPolicy(), compactionPolicy)
-    );
+    return new DruidCompactionConfig(compactionConfigs, clusterConfig);
   }
 
   public DruidCompactionConfig withDatasourceConfig(DataSourceCompactionConfig dataSourceConfig)
@@ -93,15 +84,30 @@ public DruidCompactionConfig(
       @JsonProperty("compactionConfigs") List<DataSourceCompactionConfig> compactionConfigs,
       @JsonProperty("compactionTaskSlotRatio") @Nullable Double compactionTaskSlotRatio,
       @JsonProperty("maxCompactionTaskSlots") @Nullable Integer maxCompactionTaskSlots,
-      @JsonProperty("useAutoScaleSlots") @Nullable Boolean useAutoScaleSlots,
-      @JsonProperty("compactionPolicy") @Nullable CompactionCandidateSearchPolicy compactionPolicy
+      @JsonProperty("compactionPolicy") @Nullable CompactionCandidateSearchPolicy compactionPolicy,
+      @JsonProperty("useSupervisors") @Nullable Boolean useSupervisors,
+      @JsonProperty("engine") @Nullable CompactionEngine engine
+  )
+  {
+    this(
+        compactionConfigs,
+        new ClusterCompactionConfig(
+            compactionTaskSlotRatio,
+            maxCompactionTaskSlots,
+            compactionPolicy,
+            useSupervisors,
+            engine
+        )
+    );
+  }
+
+  private DruidCompactionConfig(
+      @Nullable List<DataSourceCompactionConfig> compactionConfigs,
+      @Nullable ClusterCompactionConfig clusterConfig
   )
   {
     this.compactionConfigs = Configs.valueOrDefault(compactionConfigs, Collections.emptyList());
-    this.compactionTaskSlotRatio = Configs.valueOrDefault(compactionTaskSlotRatio, 0.1);
-    this.maxCompactionTaskSlots = Configs.valueOrDefault(maxCompactionTaskSlots, Integer.MAX_VALUE);
-    this.useAutoScaleSlots = Configs.valueOrDefault(useAutoScaleSlots, false);
-    this.compactionPolicy = Configs.valueOrDefault(compactionPolicy, DEFAULT_COMPACTION_POLICY);
+    this.clusterConfig = clusterConfig;
   }
 
   @JsonProperty
@@ -113,31 +119,33 @@ public List<DataSourceCompactionConfig> getCompactionConfigs()
   @JsonProperty
   public double getCompactionTaskSlotRatio()
   {
-    return compactionTaskSlotRatio;
+    return clusterConfig.getCompactionTaskSlotRatio();
   }
 
   @JsonProperty
   public int getMaxCompactionTaskSlots()
   {
-    return maxCompactionTaskSlots;
+    return clusterConfig.getMaxCompactionTaskSlots();
   }
 
   @JsonProperty
-  public boolean isUseAutoScaleSlots()
+  public boolean isUseSupervisors()
   {
-    return useAutoScaleSlots;
+    return clusterConfig.getUseSupervisors();
   }
 
+  @JsonProperty
+  public CompactionEngine getEngine()
+  {
+    return clusterConfig.getEngine();
+  }
 
-  // Null-safe getters not used for serialization
+  /**
+   * Returns the cluster-level compaction config. Not used for serialization.
+   */
   public ClusterCompactionConfig clusterConfig()
   {
-    return new ClusterCompactionConfig(
-        compactionTaskSlotRatio,
-        maxCompactionTaskSlots,
-        useAutoScaleSlots,
-        compactionPolicy
-    );
+    return clusterConfig;
   }
 
   public Map<String, DataSourceCompactionConfig> dataSourceToCompactionConfigMap()
@@ -160,7 +168,7 @@ public Optional<DataSourceCompactionConfig> findConfigForDatasource(String dataS
   @JsonProperty
   public CompactionCandidateSearchPolicy getCompactionPolicy()
   {
-    return compactionPolicy;
+    return clusterConfig.getCompactionPolicy();
   }
 
   @Override
@@ -173,23 +181,14 @@ public boolean equals(Object o)
       return false;
     }
     DruidCompactionConfig that = (DruidCompactionConfig) o;
-    return Double.compare(that.compactionTaskSlotRatio, compactionTaskSlotRatio) == 0 &&
-           maxCompactionTaskSlots == that.maxCompactionTaskSlots &&
-           useAutoScaleSlots == that.useAutoScaleSlots &&
-           Objects.equals(compactionPolicy, that.compactionPolicy) &&
+    return Objects.equals(clusterConfig, that.clusterConfig) &&
            Objects.equals(compactionConfigs, that.compactionConfigs);
   }
 
   @Override
   public int hashCode()
   {
-    return Objects.hash(
-        compactionConfigs,
-        compactionTaskSlotRatio,
-        maxCompactionTaskSlots,
-        useAutoScaleSlots,
-        compactionPolicy
-    );
+    return Objects.hash(clusterConfig, compactionConfigs);
   }
 
   @Override
@@ -197,10 +196,7 @@ public String toString()
   {
     return "CoordinatorCompactionConfig{" +
            "compactionConfigs=" + compactionConfigs +
-           ", compactionTaskSlotRatio=" + compactionTaskSlotRatio +
-           ", maxCompactionTaskSlots=" + maxCompactionTaskSlots +
-           ", useAutoScaleSlots=" + useAutoScaleSlots +
-           ", compactionPolicy=" + compactionPolicy +
+           ", clusterConfig=" + clusterConfig +
            '}';
   }
 }
diff --git a/server/src/main/java/org/apache/druid/server/http/CoordinatorCompactionConfigsResource.java b/server/src/main/java/org/apache/druid/server/http/CoordinatorCompactionConfigsResource.java
index 5215f7de4e26..f2cad3b455b2 100644
--- a/server/src/main/java/org/apache/druid/server/http/CoordinatorCompactionConfigsResource.java
+++ b/server/src/main/java/org/apache/druid/server/http/CoordinatorCompactionConfigsResource.java
@@ -112,7 +112,6 @@ public Response updateClusterCompactionConfig(
   public Response setCompactionTaskLimit(
       @QueryParam("ratio") Double compactionTaskSlotRatio,
       @QueryParam("max") Integer maxCompactionTaskSlots,
-      @QueryParam("useAutoScaleSlots") Boolean useAutoScaleSlots,
       @Context HttpServletRequest req
   )
   {
@@ -120,7 +119,8 @@ public Response setCompactionTaskLimit(
         new ClusterCompactionConfig(
             compactionTaskSlotRatio,
             maxCompactionTaskSlots,
-            useAutoScaleSlots,
+            null,
+            null,
             null
         ),
         req
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/CompactionSupervisorConfigTest.java b/server/src/test/java/org/apache/druid/server/coordinator/CompactionSupervisorConfigTest.java
deleted file mode 100644
index 59cc3ecf1718..000000000000
--- a/server/src/test/java/org/apache/druid/server/coordinator/CompactionSupervisorConfigTest.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.apache.druid.server.coordinator;
-
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.google.common.collect.ImmutableMap;
-import org.apache.druid.indexer.CompactionEngine;
-import org.apache.druid.jackson.DefaultObjectMapper;
-import org.junit.Assert;
-import org.junit.Test;
-
-public class CompactionSupervisorConfigTest
-{
-  private static final ObjectMapper OBJECT_MAPPER = new DefaultObjectMapper();
-
-  @Test
-  public void testCompactionSupervisorConfigSerde() throws JsonProcessingException
-  {
-    final boolean enabled = true;
-    final CompactionEngine defaultEngine = CompactionEngine.MSQ;
-    CompactionSupervisorConfig compactionSupervisorConfig =
-        OBJECT_MAPPER.readValue(
-            OBJECT_MAPPER.writeValueAsString(ImmutableMap.of("enabled", enabled, "engine", defaultEngine)),
-            CompactionSupervisorConfig.class
-        );
-    Assert.assertEquals(new CompactionSupervisorConfig(enabled, defaultEngine), compactionSupervisorConfig);
-  }
-
-  @Test
-  public void testCompactionSupervisorConfigEquality()
-  {
-    Assert.assertEquals(
-        new CompactionSupervisorConfig(true, CompactionEngine.MSQ),
-        new CompactionSupervisorConfig(true, CompactionEngine.MSQ)
-    );
-    Assert.assertNotEquals(
-        new CompactionSupervisorConfig(true, CompactionEngine.NATIVE),
-        new CompactionSupervisorConfig(true, CompactionEngine.MSQ)
-    );
-    Assert.assertNotEquals(new CompactionSupervisorConfig(true, CompactionEngine.NATIVE), "true");
-  }
-}
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/DataSourceCompactionConfigAuditEntryTest.java b/server/src/test/java/org/apache/druid/server/coordinator/DataSourceCompactionConfigAuditEntryTest.java
index 4647ad8d9853..71fd30dbfd2a 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/DataSourceCompactionConfigAuditEntryTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/DataSourceCompactionConfigAuditEntryTest.java
@@ -33,7 +33,7 @@ public class DataSourceCompactionConfigAuditEntryTest
   private final AuditInfo auditInfo = new AuditInfo("author", "identity", "comment", "ip");
   
   private final DataSourceCompactionConfigAuditEntry firstEntry = new DataSourceCompactionConfigAuditEntry(
-      new ClusterCompactionConfig(0.1, 9, true, null),
+      new ClusterCompactionConfig(0.1, 9, null, null, null),
       DataSourceCompactionConfig.builder().forDataSource(TestDataSource.WIKI).build(),
       auditInfo,
       DateTimes.nowUtc()
@@ -43,7 +43,7 @@ public class DataSourceCompactionConfigAuditEntryTest
   public void testhasSameConfigWithSameBaseConfigIsTrue()
   {
     final DataSourceCompactionConfigAuditEntry secondEntry = new DataSourceCompactionConfigAuditEntry(
-        new ClusterCompactionConfig(0.1, 9, true, null),
+        new ClusterCompactionConfig(0.1, 9, null, null, null),
         DataSourceCompactionConfig.builder().forDataSource(TestDataSource.WIKI).build(),
         auditInfo,
         DateTimes.nowUtc()
@@ -56,7 +56,7 @@ public void testhasSameConfigWithSameBaseConfigIsTrue()
   public void testhasSameConfigWithDifferentClusterConfigIsFalse()
   {
     DataSourceCompactionConfigAuditEntry secondEntry = new DataSourceCompactionConfigAuditEntry(
-        new ClusterCompactionConfig(0.2, 9, false, null),
+        new ClusterCompactionConfig(0.2, 9, null, null, null),
         DataSourceCompactionConfig.builder().forDataSource(TestDataSource.WIKI).build(),
         auditInfo,
         DateTimes.nowUtc()
@@ -65,7 +65,7 @@ public void testhasSameConfigWithDifferentClusterConfigIsFalse()
     Assert.assertFalse(secondEntry.hasSameConfig(firstEntry));
 
     secondEntry = new DataSourceCompactionConfigAuditEntry(
-        new ClusterCompactionConfig(0.1, 10, true, null),
+        new ClusterCompactionConfig(0.1, 10, null, null, null),
         DataSourceCompactionConfig.builder().forDataSource(TestDataSource.WIKI).build(),
         auditInfo,
         DateTimes.nowUtc()
@@ -78,7 +78,7 @@ public void testhasSameConfigWithDifferentClusterConfigIsFalse()
   public void testhasSameConfigWithDifferentDatasourceConfigIsFalse()
   {
     DataSourceCompactionConfigAuditEntry secondEntry = new DataSourceCompactionConfigAuditEntry(
-        new ClusterCompactionConfig(0.1, 9, true, null),
+        new ClusterCompactionConfig(0.1, 9, null, null, null),
         DataSourceCompactionConfig.builder().forDataSource(TestDataSource.KOALA).build(),
         auditInfo,
         DateTimes.nowUtc()
@@ -91,7 +91,7 @@ public void testhasSameConfigWithDifferentDatasourceConfigIsFalse()
   public void testhasSameConfigWithNullDatasourceConfigIsFalse()
   {
     final DataSourceCompactionConfigAuditEntry secondEntry = new DataSourceCompactionConfigAuditEntry(
-        new ClusterCompactionConfig(0.1, 9, true, null),
+        new ClusterCompactionConfig(0.1, 9, null, null, null),
         null,
         auditInfo,
         DateTimes.nowUtc()
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/DataSourceCompactionConfigHistoryTest.java b/server/src/test/java/org/apache/druid/server/coordinator/DataSourceCompactionConfigHistoryTest.java
index bcdee91ecd52..ba670c31248b 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/DataSourceCompactionConfigHistoryTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/DataSourceCompactionConfigHistoryTest.java
@@ -177,7 +177,7 @@ public void testAddAndModifyClusterConfigShouldAddTwice()
     wikiAuditHistory.add(originalConfig, auditInfo, DateTimes.nowUtc());
 
     final DruidCompactionConfig updatedConfig = originalConfig.withClusterConfig(
-        new ClusterCompactionConfig(0.2, null, null, null)
+        new ClusterCompactionConfig(0.2, null, null, null, null)
     );
     wikiAuditHistory.add(updatedConfig, auditInfo, DateTimes.nowUtc());
 
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/DruidCompactionConfigTest.java b/server/src/test/java/org/apache/druid/server/coordinator/DruidCompactionConfigTest.java
index 2f481727fa10..ffd3b453b8f7 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/DruidCompactionConfigTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/DruidCompactionConfigTest.java
@@ -64,6 +64,7 @@ public void testSerdeWithDatasourceConfigs() throws Exception
         null,
         null,
         null,
+        null,
         null
     );
 
@@ -80,8 +81,9 @@ public void testCopyWithClusterConfig()
     final ClusterCompactionConfig clusterConfig = new ClusterCompactionConfig(
         0.5,
         10,
-        false,
-        new NewestSegmentFirstPolicy(null)
+        new NewestSegmentFirstPolicy(null),
+        true,
+        CompactionEngine.MSQ
     );
     final DruidCompactionConfig copy = config.withClusterConfig(clusterConfig);
 
@@ -106,4 +108,15 @@ public void testCopyWithDatasourceConfigs()
     Assert.assertEquals(1, copy.getCompactionConfigs().size());
     Assert.assertEquals(dataSourceConfig, copy.findConfigForDatasource(TestDataSource.WIKI).orNull());
   }
+
+  @Test
+  public void testDefaultConfigValues()
+  {
+    final DruidCompactionConfig config = DruidCompactionConfig.empty();
+    Assert.assertTrue(config.getCompactionConfigs().isEmpty());
+    Assert.assertTrue(config.getCompactionPolicy() instanceof NewestSegmentFirstPolicy);
+    Assert.assertEquals(CompactionEngine.NATIVE, config.getEngine());
+    Assert.assertEquals(0.1, config.getCompactionTaskSlotRatio(), 1e-9);
+    Assert.assertEquals(Integer.MAX_VALUE, config.getMaxCompactionTaskSlots());
+  }
 }
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorTest.java b/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorTest.java
index d50e82e7baa0..abe5dce051f5 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorTest.java
@@ -821,7 +821,7 @@ public void testSimulateRunWithEmptyDatasourceCompactionConfigs()
         .anyTimes();
     EasyMock.replay(segmentsMetadataManager);
     CompactionSimulateResult result = coordinator.simulateRunWithConfigUpdate(
-        new ClusterCompactionConfig(0.2, null, null, null)
+        new ClusterCompactionConfig(0.2, null, null, null, null)
     );
     Assert.assertEquals(Collections.emptyMap(), result.getCompactionStates());
   }
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/duty/CompactSegmentsTest.java b/server/src/test/java/org/apache/druid/server/coordinator/duty/CompactSegmentsTest.java
index e1a5ed52e335..3a887e9fec3b 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/duty/CompactSegmentsTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/duty/CompactSegmentsTest.java
@@ -672,7 +672,7 @@ public void testRunMultipleCompactionTaskSlotsWithUseAutoScaleSlotsOverMaxSlot()
     final TestOverlordClient overlordClient = new TestOverlordClient(JSON_MAPPER);
     final CompactSegments compactSegments = new CompactSegments(statusTracker, overlordClient);
     final CoordinatorRunStats stats =
-        doCompactSegments(compactSegments, createCompactionConfigs(), maxCompactionSlot, true);
+        doCompactSegments(compactSegments, createCompactionConfigs(), maxCompactionSlot);
     Assert.assertEquals(maxCompactionSlot, stats.get(Stats.Compaction.AVAILABLE_SLOTS));
     Assert.assertEquals(maxCompactionSlot, stats.get(Stats.Compaction.MAX_SLOTS));
     // Native takes up 1 task slot by default whereas MSQ takes up all available upto 5. Since there are 3 available
@@ -692,7 +692,7 @@ public void testRunMultipleCompactionTaskSlotsWithUseAutoScaleSlotsUnderMaxSlot(
     final TestOverlordClient overlordClient = new TestOverlordClient(JSON_MAPPER);
     final CompactSegments compactSegments = new CompactSegments(statusTracker, overlordClient);
     final CoordinatorRunStats stats =
-        doCompactSegments(compactSegments, createCompactionConfigs(), maxCompactionSlot, true);
+        doCompactSegments(compactSegments, createCompactionConfigs(), maxCompactionSlot);
     Assert.assertEquals(MAXIMUM_CAPACITY_WITH_AUTO_SCALE, stats.get(Stats.Compaction.AVAILABLE_SLOTS));
     Assert.assertEquals(MAXIMUM_CAPACITY_WITH_AUTO_SCALE, stats.get(Stats.Compaction.MAX_SLOTS));
     // Native takes up 1 task slot by default whereas MSQ takes up all available upto 5. Since there are 10 available
@@ -1865,16 +1865,6 @@ private CoordinatorRunStats doCompactSegments(
       List<DataSourceCompactionConfig> compactionConfigs,
       @Nullable Integer numCompactionTaskSlots
   )
-  {
-    return doCompactSegments(compactSegments, compactionConfigs, numCompactionTaskSlots, false);
-  }
-
-  private CoordinatorRunStats doCompactSegments(
-      CompactSegments compactSegments,
-      List<DataSourceCompactionConfig> compactionConfigs,
-      @Nullable Integer numCompactionTaskSlots,
-      boolean useAutoScaleSlots
-  )
   {
     DruidCoordinatorRuntimeParams params = DruidCoordinatorRuntimeParams
         .builder()
@@ -1884,7 +1874,8 @@ private CoordinatorRunStats doCompactSegments(
                 compactionConfigs,
                 numCompactionTaskSlots == null ? null : 1.0, // 100% when numCompactionTaskSlots is not null
                 numCompactionTaskSlots,
-                useAutoScaleSlots,
+                null,
+                null,
                 null
             )
         )
diff --git a/server/src/test/java/org/apache/druid/server/http/CoordinatorCompactionConfigsResourceTest.java b/server/src/test/java/org/apache/druid/server/http/CoordinatorCompactionConfigsResourceTest.java
index 4cef66d2ac55..029c0290c917 100644
--- a/server/src/test/java/org/apache/druid/server/http/CoordinatorCompactionConfigsResourceTest.java
+++ b/server/src/test/java/org/apache/druid/server/http/CoordinatorCompactionConfigsResourceTest.java
@@ -104,15 +104,16 @@ public void testGetDefaultClusterConfig()
 
     Assert.assertEquals(0.1, defaultConfig.getCompactionTaskSlotRatio(), DELTA);
     Assert.assertEquals(Integer.MAX_VALUE, defaultConfig.getMaxCompactionTaskSlots());
-    Assert.assertFalse(defaultConfig.isUseAutoScaleSlots());
     Assert.assertTrue(defaultConfig.getCompactionConfigs().isEmpty());
+    Assert.assertFalse(defaultConfig.isUseSupervisors());
+    Assert.assertEquals(CompactionEngine.NATIVE, defaultConfig.getEngine());
   }
 
   @Test
   public void testUpdateClusterConfig()
   {
     Response response = resource.updateClusterCompactionConfig(
-        new ClusterCompactionConfig(0.5, 10, true, null),
+        new ClusterCompactionConfig(0.5, 10, null, true, CompactionEngine.MSQ),
         mockHttpServletRequest
     );
     verifyStatus(Response.Status.OK, response);
@@ -125,7 +126,8 @@ public void testUpdateClusterConfig()
     Assert.assertNotNull(updatedConfig);
     Assert.assertEquals(0.5, updatedConfig.getCompactionTaskSlotRatio(), DELTA);
     Assert.assertEquals(10, updatedConfig.getMaxCompactionTaskSlots());
-    Assert.assertTrue(updatedConfig.isUseAutoScaleSlots());
+    Assert.assertTrue(updatedConfig.isUseSupervisors());
+    Assert.assertEquals(CompactionEngine.MSQ, updatedConfig.getEngine());
   }
 
   @Test
@@ -134,7 +136,7 @@ public void testSetCompactionTaskLimit()
     final DruidCompactionConfig defaultConfig
         = verifyAndGetPayload(resource.getCompactionConfig(), DruidCompactionConfig.class);
 
-    Response response = resource.setCompactionTaskLimit(0.5, 9, true, mockHttpServletRequest);
+    Response response = resource.setCompactionTaskLimit(0.5, 9, mockHttpServletRequest);
     verifyStatus(Response.Status.OK, response);
 
     final DruidCompactionConfig updatedConfig
@@ -143,7 +145,6 @@ public void testSetCompactionTaskLimit()
     // Verify that the task slot fields have been updated
     Assert.assertEquals(0.5, updatedConfig.getCompactionTaskSlotRatio(), DELTA);
     Assert.assertEquals(9, updatedConfig.getMaxCompactionTaskSlots());
-    Assert.assertTrue(updatedConfig.isUseAutoScaleSlots());
 
     // Verify that the other fields are unchanged
     Assert.assertEquals(defaultConfig.getCompactionConfigs(), updatedConfig.getCompactionConfigs());

From ecd449564d3096bdfc203e8f095a42e5e386d405 Mon Sep 17 00:00:00 2001
From: Kashif Faraz <kashif.faraz@gmail.com>
Date: Mon, 24 Mar 2025 14:04:13 +0530
Subject: [PATCH 49/99] Retry segment publish task actions without holding
 locks (#17816)

#17802 reverted a retry of failed segment publish actions.

This patch attempts to address the original issue by retrying the segment publish task actions
on the client (i.e. task) side without holding any locks so that other transactions are not blocked.
Changes

    Add retries to TransactionalSegmentPublisher
    Add field retryable to SegmentPublishResult
    Remove class DataStoreMetadataUpdateResult and use SegmentPublishResult instead
---
 .../common/task/AbstractBatchIndexTask.java   |  25 +++
 .../druid/indexing/common/task/IndexTask.java |   7 +-
 .../parallel/ParallelIndexSupervisorTask.java |   8 +-
 .../seekablestream/SequenceMetadata.java      |   2 +-
 .../SegmentTransactionalInsertActionTest.java |   9 +-
 .../overlord/SegmentPublishResult.java        |  50 ++++--
 .../IndexerSQLMetadataStorageCoordinator.java | 158 ++++--------------
 .../appenderator/BaseAppenderatorDriver.java  |   3 +-
 .../TransactionalSegmentPublisher.java        |  61 ++++++-
 ...exerSQLMetadataStorageCoordinatorTest.java |  49 +++---
 ...orageCoordinatorSchemaPersistenceTest.java |   2 +-
 .../BatchAppenderatorDriverTest.java          |  18 +-
 .../StreamAppenderatorDriverTest.java         |  34 +++-
 .../TransactionalSegmentPublisherTest.java    | 104 ++++++++++++
 14 files changed, 329 insertions(+), 201 deletions(-)
 create mode 100644 server/src/test/java/org/apache/druid/segment/realtime/appenderator/TransactionalSegmentPublisherTest.java

diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/AbstractBatchIndexTask.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/AbstractBatchIndexTask.java
index 38bc961dc47a..ec9c12a14fe3 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/AbstractBatchIndexTask.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/AbstractBatchIndexTask.java
@@ -76,6 +76,7 @@
 import org.apache.druid.segment.indexing.IngestionSpec;
 import org.apache.druid.segment.indexing.TuningConfig;
 import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
+import org.apache.druid.segment.realtime.appenderator.TransactionalSegmentPublisher;
 import org.apache.druid.segment.transform.CompactionTransformSpec;
 import org.apache.druid.timeline.CompactionState;
 import org.apache.druid.timeline.DataSegment;
@@ -456,6 +457,30 @@ protected TaskAction<SegmentPublishResult> buildPublishAction(
     }
   }
 
+  protected TransactionalSegmentPublisher buildSegmentPublisher(TaskToolbox toolbox)
+  {
+    return new TransactionalSegmentPublisher()
+    {
+      @Override
+      public SegmentPublishResult publishAnnotatedSegments(
+          @Nullable Set<DataSegment> segmentsToBeOverwritten,
+          Set<DataSegment> segmentsToPublish,
+          @Nullable Object commitMetadata,
+          @Nullable SegmentSchemaMapping schemaMapping
+      ) throws IOException
+      {
+        return toolbox.getTaskActionClient().submit(
+            buildPublishAction(
+                segmentsToBeOverwritten,
+                segmentsToPublish,
+                schemaMapping,
+                getTaskLockHelper().getLockTypeToUse()
+            )
+        );
+      }
+    };
+  }
+
   protected boolean tryTimeChunkLock(TaskActionClient client, List<Interval> intervals) throws IOException
   {
     // The given intervals are first converted to align with segment granularity. This is because,
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/IndexTask.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/IndexTask.java
index eae1f7caf1e6..4ea7e9d3deec 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/IndexTask.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/IndexTask.java
@@ -48,7 +48,6 @@
 import org.apache.druid.indexer.partitions.PartitionsSpec;
 import org.apache.druid.indexer.partitions.SecondaryPartitionType;
 import org.apache.druid.indexer.report.TaskReport;
-import org.apache.druid.indexing.common.TaskLockType;
 import org.apache.druid.indexing.common.TaskRealtimeMetricsMonitorBuilder;
 import org.apache.druid.indexing.common.TaskToolbox;
 import org.apache.druid.indexing.common.actions.TaskActionClient;
@@ -866,11 +865,7 @@ private TaskStatus generateAndPublishSegments(
         throw new UOE("[%s] secondary partition type is not supported", partitionsSpec.getType());
     }
 
-    final TaskLockType taskLockType = getTaskLockHelper().getLockTypeToUse();
-    final TransactionalSegmentPublisher publisher =
-        (segmentsToBeOverwritten, segmentsToPublish, commitMetadata, map) -> toolbox.getTaskActionClient().submit(
-            buildPublishAction(segmentsToBeOverwritten, segmentsToPublish, map, taskLockType)
-        );
+    final TransactionalSegmentPublisher publisher = buildSegmentPublisher(toolbox);
 
     String effectiveId = getContextValue(CompactionTask.CTX_KEY_APPENDERATOR_TRACKING_TASK_ID, null);
     if (effectiveId == null) {
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/batch/parallel/ParallelIndexSupervisorTask.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/batch/parallel/ParallelIndexSupervisorTask.java
index 86e31c74a72f..34cc71a3a127 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/batch/parallel/ParallelIndexSupervisorTask.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/batch/parallel/ParallelIndexSupervisorTask.java
@@ -45,7 +45,6 @@
 import org.apache.druid.indexer.report.IngestionStatsAndErrors;
 import org.apache.druid.indexer.report.IngestionStatsAndErrorsTaskReport;
 import org.apache.druid.indexer.report.TaskReport;
-import org.apache.druid.indexing.common.TaskLockType;
 import org.apache.druid.indexing.common.TaskToolbox;
 import org.apache.druid.indexing.common.actions.TaskActionClient;
 import org.apache.druid.indexing.common.task.AbstractBatchIndexTask;
@@ -1191,12 +1190,7 @@ private void publishSegments(
       }
     }
 
-    final TaskLockType taskLockType = getTaskLockHelper().getLockTypeToUse();
-    final TransactionalSegmentPublisher publisher =
-        (segmentsToBeOverwritten, segmentsToPublish, commitMetadata, map) -> toolbox.getTaskActionClient().submit(
-            buildPublishAction(segmentsToBeOverwritten, segmentsToPublish, map, taskLockType)
-        );
-
+    final TransactionalSegmentPublisher publisher = buildSegmentPublisher(toolbox);
     final boolean published =
         newSegments.isEmpty()
         || publisher.publishSegments(oldSegments, newSegments, annotateFunction, null, segmentSchemaMapping).isSuccess();
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/SequenceMetadata.java b/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/SequenceMetadata.java
index 2da858f80ccd..f974a1c6c932 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/SequenceMetadata.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/SequenceMetadata.java
@@ -331,7 +331,7 @@ TransactionalSegmentPublisher createPublisher(
   }
 
   private class SequenceMetadataTransactionalSegmentPublisher
-      implements TransactionalSegmentPublisher
+      extends TransactionalSegmentPublisher
   {
     private final SeekableStreamIndexTaskRunner<PartitionIdType, SequenceOffsetType, ?> runner;
     private final TaskToolbox toolbox;
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentTransactionalInsertActionTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentTransactionalInsertActionTest.java
index 44ce60b5ceb2..095e9c3b57d2 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentTransactionalInsertActionTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentTransactionalInsertActionTest.java
@@ -22,7 +22,6 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
-import org.apache.druid.error.InvalidInput;
 import org.apache.druid.indexing.common.TaskLockType;
 import org.apache.druid.indexing.common.task.NoopTask;
 import org.apache.druid.indexing.common.task.Task;
@@ -150,11 +149,9 @@ public void testFailTransactionalUpdateDataSourceMetadata() throws Exception
     );
 
     Assert.assertEquals(
-        SegmentPublishResult.fail(
-            InvalidInput.exception(
-                "The new start metadata state[ObjectMetadata{theObject=[1]}] is"
-                + " ahead of the last committed end state[null]. Try resetting the supervisor."
-            ).toString()
+        SegmentPublishResult.retryableFailure(
+            "The new start metadata state[ObjectMetadata{theObject=[1]}] is"
+            + " ahead of the last committed end state[null]. Try resetting the supervisor."
         ),
         result
     );
diff --git a/server/src/main/java/org/apache/druid/indexing/overlord/SegmentPublishResult.java b/server/src/main/java/org/apache/druid/indexing/overlord/SegmentPublishResult.java
index e4bc1645f710..04b745c812e5 100644
--- a/server/src/main/java/org/apache/druid/indexing/overlord/SegmentPublishResult.java
+++ b/server/src/main/java/org/apache/druid/indexing/overlord/SegmentPublishResult.java
@@ -22,7 +22,7 @@
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableSet;
+import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.metadata.PendingSegmentRecord;
 import org.apache.druid.segment.SegmentUtils;
 import org.apache.druid.timeline.DataSegment;
@@ -34,59 +34,59 @@
 import java.util.Set;
 
 /**
- * Result of an operation that attempts to publish segments. Indicates the set of segments actually published
- * and whether or not the transaction was a success.
- *
- * If "success" is false then the segments set will be empty.
- *
- * It's possible for the segments set to be empty even if "success" is true, since the segments set only
- * includes segments actually published as part of the transaction. The requested segments could have been
- * published by a different transaction (e.g. in the case of replica sets) and this one would still succeed.
+ * Result of a segment publish operation.
  */
 public class SegmentPublishResult
 {
   private final Set<DataSegment> segments;
   private final boolean success;
-  @Nullable
+  private final boolean retryable;
   private final String errorMsg;
-  @Nullable
   private final List<PendingSegmentRecord> upgradedPendingSegments;
 
   public static SegmentPublishResult ok(Set<DataSegment> segments)
   {
-    return new SegmentPublishResult(segments, true, null);
+    return new SegmentPublishResult(segments, true, false, null);
   }
 
   public static SegmentPublishResult ok(Set<DataSegment> segments, List<PendingSegmentRecord> upgradedPendingSegments)
   {
-    return new SegmentPublishResult(segments, true, null, upgradedPendingSegments);
+    return new SegmentPublishResult(segments, true, false, null, upgradedPendingSegments);
   }
 
-  public static SegmentPublishResult fail(String errorMsg)
+  public static SegmentPublishResult fail(String errorMsg, Object... args)
   {
-    return new SegmentPublishResult(ImmutableSet.of(), false, errorMsg);
+    return new SegmentPublishResult(Set.of(), false, false, StringUtils.format(errorMsg, args), null);
+  }
+
+  public static SegmentPublishResult retryableFailure(String errorMsg, Object... args)
+  {
+    return new SegmentPublishResult(Set.of(), false, true, StringUtils.format(errorMsg, args), null);
   }
 
   @JsonCreator
   private SegmentPublishResult(
       @JsonProperty("segments") Set<DataSegment> segments,
       @JsonProperty("success") boolean success,
+      @JsonProperty("retryable") boolean retryable,
       @JsonProperty("errorMsg") @Nullable String errorMsg
   )
   {
-    this(segments, success, errorMsg, null);
+    this(segments, success, retryable, errorMsg, null);
   }
 
   private SegmentPublishResult(
       Set<DataSegment> segments,
       boolean success,
-       @Nullable String errorMsg,
+      boolean retryable,
+      @Nullable String errorMsg,
       List<PendingSegmentRecord> upgradedPendingSegments
   )
   {
     this.segments = Preconditions.checkNotNull(segments, "segments");
     this.success = success;
     this.errorMsg = errorMsg;
+    this.retryable = retryable;
     this.upgradedPendingSegments = upgradedPendingSegments;
 
     if (!success) {
@@ -98,6 +98,12 @@ private SegmentPublishResult(
     }
   }
 
+  /**
+   * Set of segments published successfully.
+   *
+   * @return Empty set if the publish operation failed or if all the segments had
+   * already been published by a different transaction.
+   */
   @JsonProperty
   public Set<DataSegment> getSegments()
   {
@@ -117,6 +123,12 @@ public String getErrorMsg()
     return errorMsg;
   }
 
+  @JsonProperty
+  public boolean isRetryable()
+  {
+    return retryable;
+  }
+
   @Nullable
   public List<PendingSegmentRecord> getUpgradedPendingSegments()
   {
@@ -134,6 +146,7 @@ public boolean equals(Object o)
     }
     SegmentPublishResult that = (SegmentPublishResult) o;
     return success == that.success &&
+           retryable == that.retryable &&
            Objects.equals(segments, that.segments) &&
            Objects.equals(errorMsg, that.errorMsg);
   }
@@ -141,7 +154,7 @@ public boolean equals(Object o)
   @Override
   public int hashCode()
   {
-    return Objects.hash(segments, success, errorMsg);
+    return Objects.hash(segments, success, errorMsg, retryable);
   }
 
   @Override
@@ -150,6 +163,7 @@ public String toString()
     return "SegmentPublishResult{" +
            "segments=" + SegmentUtils.commaSeparatedIdentifiers(segments) +
            ", success=" + success +
+           ", retryable=" + retryable +
            ", errorMsg='" + errorMsg + '\'' +
            '}';
   }
diff --git a/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java b/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java
index ce092f8c6967..9a0f91d6afd6 100644
--- a/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java
+++ b/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java
@@ -91,7 +91,6 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
-import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
@@ -306,33 +305,22 @@ public SegmentPublishResult commitSegmentsAndMetadata(
 
     final String dataSource = segments.iterator().next().getDataSource();
 
-    final AtomicBoolean definitelyNotUpdated = new AtomicBoolean(false);
-
     try {
       return inReadWriteDatasourceTransaction(
           dataSource,
           transaction -> {
-            // Set definitelyNotUpdated back to false upon retrying.
-            definitelyNotUpdated.set(false);
-
+            // Try to update datasource metadata first
             if (startMetadata != null) {
-              final DataStoreMetadataUpdateResult result = updateDataSourceMetadataWithHandle(
+              final SegmentPublishResult result = updateDataSourceMetadataWithHandle(
                   transaction,
                   dataSource,
                   startMetadata,
                   endMetadata
               );
 
-              if (result.isFailed()) {
-                // Metadata was definitely not updated.
-                transaction.setRollbackOnly();
-                definitelyNotUpdated.set(true);
-
-                if (result.canRetry()) {
-                  throw new RetryTransactionException(result.getErrorMsg());
-                } else {
-                  throw InvalidInput.exception(result.getErrorMsg());
-                }
+              // Do not proceed if the datasource metadata update failed
+              if (!result.isSuccess()) {
+                return result;
               }
             }
 
@@ -347,12 +335,7 @@ public SegmentPublishResult commitSegmentsAndMetadata(
       );
     }
     catch (CallbackFailedException e) {
-      if (definitelyNotUpdated.get()) {
-        return SegmentPublishResult.fail(e.getMessage());
-      } else {
-        // Must throw exception if we are not sure if we updated or not.
-        throw e;
-      }
+      throw e;
     }
   }
 
@@ -468,45 +451,19 @@ public SegmentPublishResult commitMetadataOnly(
       throw new IllegalArgumentException("end metadata cannot be null");
     }
 
-    final AtomicBoolean definitelyNotUpdated = new AtomicBoolean(false);
-
     try {
       return inReadWriteDatasourceTransaction(
           dataSource,
-          transaction -> {
-            // Set definitelyNotUpdated back to false upon retrying.
-            definitelyNotUpdated.set(false);
-
-            final DataStoreMetadataUpdateResult result = updateDataSourceMetadataWithHandle(
-                transaction,
-                dataSource,
-                startMetadata,
-                endMetadata
-            );
-
-            if (result.isFailed()) {
-              // Metadata was definitely not updated.
-              transaction.setRollbackOnly();
-              definitelyNotUpdated.set(true);
-
-              if (result.canRetry()) {
-                throw new RetryTransactionException(result.getErrorMsg());
-              } else {
-                throw new RuntimeException(result.getErrorMsg());
-              }
-            }
-
-            return SegmentPublishResult.ok(ImmutableSet.of());
-          }
+          transaction -> updateDataSourceMetadataWithHandle(
+              transaction,
+              dataSource,
+              startMetadata,
+              endMetadata
+          )
       );
     }
     catch (CallbackFailedException e) {
-      if (definitelyNotUpdated.get()) {
-        return SegmentPublishResult.fail(e.getMessage());
-      } else {
-        // Must throw exception if we are not sure if we updated or not.
-        throw e;
-      }
+      throw e;
     }
   }
 
@@ -1126,25 +1083,18 @@ private SegmentPublishResult commitAppendSegmentsAndMetadataInTransaction(
         }
     );
 
-    final AtomicBoolean metadataNotUpdated = new AtomicBoolean(false);
     try {
       return inReadWriteDatasourceTransaction(
           dataSource,
           transaction -> {
-            metadataNotUpdated.set(false);
-
+            // Try to update datasource metadata first
             if (startMetadata != null) {
-              final DataStoreMetadataUpdateResult metadataUpdateResult
+              final SegmentPublishResult metadataUpdateResult
                   = updateDataSourceMetadataWithHandle(transaction, dataSource, startMetadata, endMetadata);
 
-              if (metadataUpdateResult.isFailed()) {
-                transaction.setRollbackOnly();
-                metadataNotUpdated.set(true);
-                if (metadataUpdateResult.canRetry()) {
-                  throw new RetryTransactionException(metadataUpdateResult.getErrorMsg());
-                } else {
-                  throw new RuntimeException(metadataUpdateResult.getErrorMsg());
-                }
+              // Abort the transaction if datasource metadata update has failed
+              if (!metadataUpdateResult.isSuccess()) {
+                return metadataUpdateResult;
               }
             }
 
@@ -1172,12 +1122,7 @@ private SegmentPublishResult commitAppendSegmentsAndMetadataInTransaction(
       );
     }
     catch (CallbackFailedException e) {
-      if (metadataNotUpdated.get()) {
-        // Return failed result if metadata was definitely not updated
-        return SegmentPublishResult.fail(e.getMessage());
-      } else {
-        throw e;
-      }
+      throw e;
     }
   }
 
@@ -2052,7 +1997,7 @@ private Map<String, String> getAppendSegmentsCommittedDuringTask(
    *
    * @throws RuntimeException if state is unknown after this call
    */
-  protected DataStoreMetadataUpdateResult updateDataSourceMetadataWithHandle(
+  protected SegmentPublishResult updateDataSourceMetadataWithHandle(
       final SegmentMetadataTransaction transaction,
       final String dataSource,
       final DataSourceMetadata startMetadata,
@@ -2102,7 +2047,9 @@ protected DataStoreMetadataUpdateResult updateDataSourceMetadataWithHandle(
 
     if (startMetadataGreaterThanExisting && !startMetadataMatchesExisting) {
       // Offsets stored in startMetadata is greater than the last commited metadata.
-      return DataStoreMetadataUpdateResult.failure(
+      // This can happen because the previous task is still publishing its segments and can resolve once
+      // the previous task finishes publishing.
+      return SegmentPublishResult.retryableFailure(
           "The new start metadata state[%s] is ahead of the last committed"
           + " end state[%s]. Try resetting the supervisor.",
           startMetadata, oldCommitMetadataFromDb
@@ -2111,7 +2058,7 @@ protected DataStoreMetadataUpdateResult updateDataSourceMetadataWithHandle(
 
     if (!startMetadataMatchesExisting) {
       // Not in the desired start state.
-      return DataStoreMetadataUpdateResult.failure(
+      return SegmentPublishResult.fail(
           "Inconsistency between stored metadata state[%s] and target state[%s]. Try resetting the supervisor.",
           oldCommitMetadataFromDb, startMetadata
       );
@@ -2126,7 +2073,7 @@ protected DataStoreMetadataUpdateResult updateDataSourceMetadataWithHandle(
         Hashing.sha1().hashBytes(newCommitMetadataBytes).asBytes()
     );
 
-    final DataStoreMetadataUpdateResult retVal;
+    final SegmentPublishResult retVal;
     if (oldCommitMetadataBytesFromDb == null) {
       // SELECT -> INSERT can fail due to races; callers must be prepared to retry.
       final int numRows = transaction.getHandle().createStatement(
@@ -2143,8 +2090,8 @@ protected DataStoreMetadataUpdateResult updateDataSourceMetadataWithHandle(
                                 .execute();
 
       retVal = numRows == 1
-          ? DataStoreMetadataUpdateResult.SUCCESS
-          : DataStoreMetadataUpdateResult.retryableFailure("Failed to insert metadata for datasource[%s]", dataSource);
+          ? SegmentPublishResult.ok(Set.of())
+          : SegmentPublishResult.retryableFailure("Failed to insert metadata for datasource[%s]", dataSource);
     } else {
       // Expecting a particular old metadata; use the SHA1 in a compare-and-swap UPDATE
       final int numRows = transaction.getHandle().createStatement(
@@ -2163,8 +2110,8 @@ protected DataStoreMetadataUpdateResult updateDataSourceMetadataWithHandle(
                                 .execute();
 
       retVal = numRows == 1
-          ? DataStoreMetadataUpdateResult.SUCCESS
-          : DataStoreMetadataUpdateResult.retryableFailure("Failed to update metadata for datasource[%s]", dataSource);
+          ? SegmentPublishResult.ok(Set.of())
+          : SegmentPublishResult.retryableFailure("Failed to update metadata for datasource[%s]", dataSource);
     }
 
     if (retVal.isSuccess()) {
@@ -2521,51 +2468,4 @@ private <T> T inReadOnlyDatasourceTransaction(
   {
     return transactionFactory.inReadOnlyDatasourceTransaction(dataSource, callback);
   }
-
-  public static class DataStoreMetadataUpdateResult
-  {
-    private final boolean failed;
-    private final boolean canRetry;
-    private final String errorMsg;
-
-    public static final DataStoreMetadataUpdateResult SUCCESS = new DataStoreMetadataUpdateResult(false, false, null);
-
-    public static DataStoreMetadataUpdateResult failure(String errorMsgFormat, Object... messageArgs)
-    {
-      return new DataStoreMetadataUpdateResult(true, false, errorMsgFormat, messageArgs);
-    }
-
-    public static DataStoreMetadataUpdateResult retryableFailure(String errorMsgFormat, Object... messageArgs)
-    {
-      return new DataStoreMetadataUpdateResult(true, true, errorMsgFormat, messageArgs);
-    }
-
-    DataStoreMetadataUpdateResult(boolean failed, boolean canRetry, @Nullable String errorMsg, Object... errorFormatArgs)
-    {
-      this.failed = failed;
-      this.canRetry = canRetry;
-      this.errorMsg = null == errorMsg ? null : StringUtils.format(errorMsg, errorFormatArgs);
-    }
-
-    public boolean isFailed()
-    {
-      return failed;
-    }
-
-    public boolean isSuccess()
-    {
-      return !failed;
-    }
-
-    public boolean canRetry()
-    {
-      return canRetry;
-    }
-
-    @Nullable
-    public String getErrorMsg()
-    {
-      return errorMsg;
-    }
-  }
 }
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/BaseAppenderatorDriver.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/BaseAppenderatorDriver.java
index fa7d037c92cf..7ca7fd74c2db 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/BaseAppenderatorDriver.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/BaseAppenderatorDriver.java
@@ -719,7 +719,8 @@ ListenableFuture<SegmentsAndCommitMetadata> publishInBackground(
               e -> (e != null && e.getMessage() != null
                     && e.getMessage().contains("Failed to update the metadata Store."
                                                + " The new start metadata is ahead of last commited end state.")),
-              RetryUtils.DEFAULT_MAX_TRIES
+              // Do not retry here since the TransactionalSegmentPublisher itself performs required retries
+              1
           );
         }
         catch (Exception e) {
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/TransactionalSegmentPublisher.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/TransactionalSegmentPublisher.java
index 390f423fdb5f..eb84b50399ad 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/TransactionalSegmentPublisher.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/TransactionalSegmentPublisher.java
@@ -20,6 +20,9 @@
 package org.apache.druid.segment.realtime.appenderator;
 
 import org.apache.druid.indexing.overlord.SegmentPublishResult;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.segment.SegmentSchemaMapping;
 import org.apache.druid.timeline.DataSegment;
 
@@ -28,8 +31,11 @@
 import java.util.Set;
 import java.util.function.Function;
 
-public interface TransactionalSegmentPublisher
+public abstract class TransactionalSegmentPublisher
 {
+  private static final int QUIET_RETRIES = 3;
+  private static final int MAX_RETRIES = 5;
+
   /**
    * Publish segments, along with some commit metadata, in a single transaction.
    *
@@ -40,14 +46,19 @@ public interface TransactionalSegmentPublisher
    * @throws IOException if there was an I/O error when publishing
    * @throws RuntimeException if we cannot tell if the segments were published or not, for some other reason
    */
-  SegmentPublishResult publishAnnotatedSegments(
+  public abstract SegmentPublishResult publishAnnotatedSegments(
       @Nullable Set<DataSegment> segmentsToBeOverwritten,
       Set<DataSegment> segmentsToPublish,
       @Nullable Object commitMetadata,
       @Nullable SegmentSchemaMapping segmentSchemaMapping
   ) throws IOException;
 
-  default SegmentPublishResult publishSegments(
+  /**
+   * Applies the given annotate function on the segments and tries to publish
+   * them. If the action fails with a retryable failure, it can be retried upto
+   * {@link #MAX_RETRIES} times.
+   */
+  public final SegmentPublishResult publishSegments(
       @Nullable Set<DataSegment> segmentsToBeOverwritten,
       Set<DataSegment> segmentsToPublish,
       Function<Set<DataSegment>, Set<DataSegment>> outputSegmentsAnnotateFunction,
@@ -57,20 +68,58 @@ default SegmentPublishResult publishSegments(
   {
     final Function<Set<DataSegment>, Set<DataSegment>> annotateFunction = outputSegmentsAnnotateFunction
         .andThen(SegmentPublisherHelper::annotateShardSpec);
-    return publishAnnotatedSegments(
+    final Set<DataSegment> annotatedSegmentsToPublish = annotateFunction.apply(segmentsToPublish);
+
+    int attemptCount = 0;
+
+    // Retry until success or until max retries are exhausted
+    SegmentPublishResult result = publishAnnotatedSegments(
         segmentsToBeOverwritten,
-        annotateFunction.apply(segmentsToPublish),
+        annotatedSegmentsToPublish,
         commitMetadata,
         segmentSchemaMapping
     );
+    while (!result.isSuccess() && result.isRetryable() && attemptCount++ < MAX_RETRIES) {
+      awaitNextRetry(result, attemptCount);
+      result = publishAnnotatedSegments(
+          segmentsToBeOverwritten,
+          annotatedSegmentsToPublish,
+          commitMetadata,
+          segmentSchemaMapping
+      );
+    }
+
+    return result;
   }
 
   /**
    * @return true if this publisher has action to take when publishing with an empty segment set.
    *         The publisher used by the seekable stream tasks is an example where this is true.
    */
-  default boolean supportsEmptyPublish()
+  public boolean supportsEmptyPublish()
   {
     return false;
   }
+
+  /**
+   * Sleeps until the next attempt.
+   */
+  private static void awaitNextRetry(SegmentPublishResult lastResult, int attemptCount)
+  {
+    try {
+      RetryUtils.awaitNextRetry(
+          new ISE(lastResult.getErrorMsg()),
+          StringUtils.format(
+              "Segment publish failed due to error[%s]",
+              lastResult.getErrorMsg()
+          ),
+          attemptCount,
+          MAX_RETRIES,
+          attemptCount <= QUIET_RETRIES
+      );
+    }
+    catch (InterruptedException e) {
+      throw new RuntimeException(e);
+    }
+  }
 }
diff --git a/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java b/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java
index b6578fa9a721..0212c8f2d998 100644
--- a/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java
+++ b/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java
@@ -24,7 +24,6 @@
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import org.apache.druid.data.input.StringTuple;
-import org.apache.druid.error.InvalidInput;
 import org.apache.druid.indexing.overlord.DataSourceMetadata;
 import org.apache.druid.indexing.overlord.ObjectMetadata;
 import org.apache.druid.indexing.overlord.SegmentCreateRequest;
@@ -186,7 +185,7 @@ public int getMaxRetries()
     )
     {
       @Override
-      protected DataStoreMetadataUpdateResult updateDataSourceMetadataWithHandle(
+      protected SegmentPublishResult updateDataSourceMetadataWithHandle(
           SegmentMetadataTransaction transaction,
           String dataSource,
           DataSourceMetadata startMetadata,
@@ -780,7 +779,7 @@ public void testTransactionalAnnounceRetryAndSuccess() throws IOException
     )
     {
       @Override
-      protected DataStoreMetadataUpdateResult updateDataSourceMetadataWithHandle(
+      protected SegmentPublishResult updateDataSourceMetadataWithHandle(
           SegmentMetadataTransaction transaction,
           String dataSource,
           DataSourceMetadata startMetadata,
@@ -789,7 +788,7 @@ protected DataStoreMetadataUpdateResult updateDataSourceMetadataWithHandle(
       {
         metadataUpdateCounter.getAndIncrement();
         if (attemptCounter.getAndIncrement() == 0) {
-          return DataStoreMetadataUpdateResult.retryableFailure(null);
+          return SegmentPublishResult.retryableFailure("this failure can be retried");
         } else {
           return super.updateDataSourceMetadataWithHandle(transaction, dataSource, startMetadata, endMetadata);
         }
@@ -803,7 +802,15 @@ protected DataStoreMetadataUpdateResult updateDataSourceMetadataWithHandle(
         new ObjectMetadata(ImmutableMap.of("foo", "bar")),
         new SegmentSchemaMapping(CentralizedDatasourceSchemaConfig.SCHEMA_VERSION)
     );
-    Assert.assertEquals(SegmentPublishResult.ok(ImmutableSet.of(defaultSegment)), result1);
+    Assert.assertEquals(SegmentPublishResult.retryableFailure("this failure can be retried"), result1);
+
+    final SegmentPublishResult resultOnRetry = failOnceCoordinator.commitSegmentsAndMetadata(
+        ImmutableSet.of(defaultSegment),
+        new ObjectMetadata(null),
+        new ObjectMetadata(ImmutableMap.of("foo", "bar")),
+        new SegmentSchemaMapping(CentralizedDatasourceSchemaConfig.SCHEMA_VERSION)
+    );
+    Assert.assertEquals(SegmentPublishResult.ok(ImmutableSet.of(defaultSegment)), resultOnRetry);
 
     Assert.assertArrayEquals(
         mapper.writeValueAsString(defaultSegment).getBytes(StandardCharsets.UTF_8),
@@ -825,7 +832,15 @@ protected DataStoreMetadataUpdateResult updateDataSourceMetadataWithHandle(
         new ObjectMetadata(ImmutableMap.of("foo", "baz")),
         new SegmentSchemaMapping(CentralizedDatasourceSchemaConfig.SCHEMA_VERSION)
     );
-    Assert.assertEquals(SegmentPublishResult.ok(ImmutableSet.of(defaultSegment2)), result2);
+    Assert.assertEquals(SegmentPublishResult.retryableFailure("this failure can be retried"), result2);
+
+    final SegmentPublishResult resultOnRetry2 = failOnceCoordinator.commitSegmentsAndMetadata(
+        ImmutableSet.of(defaultSegment2),
+        new ObjectMetadata(ImmutableMap.of("foo", "bar")),
+        new ObjectMetadata(ImmutableMap.of("foo", "baz")),
+        new SegmentSchemaMapping(CentralizedDatasourceSchemaConfig.SCHEMA_VERSION)
+    );
+    Assert.assertEquals(SegmentPublishResult.ok(ImmutableSet.of(defaultSegment2)), resultOnRetry2);
 
     Assert.assertArrayEquals(
         mapper.writeValueAsString(defaultSegment2).getBytes(StandardCharsets.UTF_8),
@@ -857,11 +872,10 @@ public void testTransactionalAnnounceFailDbNullWantNotNull()
         new SegmentSchemaMapping(CentralizedDatasourceSchemaConfig.SCHEMA_VERSION)
     );
     Assert.assertEquals(
-        SegmentPublishResult.fail(
-            InvalidInput.exception(
-                "The new start metadata state[ObjectMetadata{theObject={foo=bar}}] is ahead of the last committed"
-                + " end state[null]. Try resetting the supervisor."
-            ).toString()),
+        SegmentPublishResult.retryableFailure(
+            "The new start metadata state[ObjectMetadata{theObject={foo=bar}}] is ahead of the last committed"
+            + " end state[null]. Try resetting the supervisor."
+        ),
         result1
     );
 
@@ -888,10 +902,8 @@ public void testTransactionalAnnounceFailDbNotNullWantNull()
     );
     Assert.assertEquals(
         SegmentPublishResult.fail(
-            InvalidInput.exception(
-                "Inconsistency between stored metadata state[ObjectMetadata{theObject={foo=baz}}]"
-                + " and target state[ObjectMetadata{theObject=null}]. Try resetting the supervisor."
-            ).toString()
+            "Inconsistency between stored metadata state[ObjectMetadata{theObject={foo=baz}}]"
+            + " and target state[ObjectMetadata{theObject=null}]. Try resetting the supervisor."
         ),
         result2
     );
@@ -972,10 +984,9 @@ public void testTransactionalAnnounceFailDbNotNullWantDifferent()
     );
     Assert.assertEquals(
         SegmentPublishResult.fail(
-            InvalidInput.exception(
-                "Inconsistency between stored metadata state[ObjectMetadata{theObject={foo=baz}}] and "
-                + "target state[ObjectMetadata{theObject={foo=qux}}]. Try resetting the supervisor."
-            ).toString()),
+            "Inconsistency between stored metadata state[ObjectMetadata{theObject={foo=baz}}] and "
+            + "target state[ObjectMetadata{theObject={foo=qux}}]. Try resetting the supervisor."
+        ),
         result2
     );
 
diff --git a/server/src/test/java/org/apache/druid/metadata/IndexerSqlMetadataStorageCoordinatorSchemaPersistenceTest.java b/server/src/test/java/org/apache/druid/metadata/IndexerSqlMetadataStorageCoordinatorSchemaPersistenceTest.java
index 9bed46b2c3a9..c72e1a75afee 100644
--- a/server/src/test/java/org/apache/druid/metadata/IndexerSqlMetadataStorageCoordinatorSchemaPersistenceTest.java
+++ b/server/src/test/java/org/apache/druid/metadata/IndexerSqlMetadataStorageCoordinatorSchemaPersistenceTest.java
@@ -108,7 +108,7 @@ public void setUp()
     )
     {
       @Override
-      protected DataStoreMetadataUpdateResult updateDataSourceMetadataWithHandle(
+      protected SegmentPublishResult updateDataSourceMetadataWithHandle(
           SegmentMetadataTransaction transaction,
           String dataSource,
           DataSourceMetadata startMetadata,
diff --git a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorDriverTest.java b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorDriverTest.java
index 085958c5f9fb..a071ff7af7d5 100644
--- a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorDriverTest.java
+++ b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorDriverTest.java
@@ -29,9 +29,11 @@
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.granularity.Granularities;
 import org.apache.druid.java.util.common.granularity.Granularity;
+import org.apache.druid.segment.SegmentSchemaMapping;
 import org.apache.druid.segment.loading.DataSegmentKiller;
 import org.apache.druid.segment.realtime.appenderator.BaseAppenderatorDriver.SegmentsForSequence;
 import org.apache.druid.segment.realtime.appenderator.SegmentWithState.SegmentState;
+import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.partition.NumberedShardSpec;
 import org.easymock.EasyMock;
 import org.easymock.EasyMockSupport;
@@ -41,11 +43,13 @@
 import org.junit.Before;
 import org.junit.Test;
 
+import javax.annotation.Nullable;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Function;
@@ -199,7 +203,19 @@ private void checkSegmentStates(int expectedNumSegmentsInState, SegmentState exp
 
   static TransactionalSegmentPublisher makeOkPublisher()
   {
-    return (segmentsToBeOverwritten, segmentsToPublish, commitMetadata, schema) -> SegmentPublishResult.ok(ImmutableSet.of());
+    return new TransactionalSegmentPublisher()
+    {
+      @Override
+      public SegmentPublishResult publishAnnotatedSegments(
+          @Nullable Set<DataSegment> segmentsToBeOverwritten,
+          Set<DataSegment> segmentsToPublish,
+          @Nullable Object commitMetadata,
+          @Nullable SegmentSchemaMapping segmentSchemaMapping
+      )
+      {
+        return SegmentPublishResult.ok(Set.of());
+      }
+    };
   }
 
   static class TestSegmentAllocator implements SegmentAllocator
diff --git a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorDriverTest.java b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorDriverTest.java
index 27aadaee574f..4bf3a8dc22b0 100644
--- a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorDriverTest.java
+++ b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorDriverTest.java
@@ -37,6 +37,7 @@
 import org.apache.druid.java.util.common.granularity.Granularities;
 import org.apache.druid.java.util.common.granularity.Granularity;
 import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.SegmentSchemaMapping;
 import org.apache.druid.segment.handoff.SegmentHandoffNotifier;
 import org.apache.druid.segment.handoff.SegmentHandoffNotifierFactory;
 import org.apache.druid.segment.loading.DataSegmentKiller;
@@ -54,9 +55,9 @@
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 
+import javax.annotation.Nullable;
 import java.io.IOException;
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -68,6 +69,7 @@
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
 
 public class StreamAppenderatorDriverTest extends EasyMockSupport
 {
@@ -411,13 +413,14 @@ private Set<SegmentIdWithShardSpec> asIdentifiers(Iterable<DataSegment> segments
 
   static TransactionalSegmentPublisher makeOkPublisher()
   {
-    return (segmentsToBeOverwritten, segmentsToPublish, commitMetadata, segmentSchemaMapping) ->
-        SegmentPublishResult.ok(Collections.emptySet());
+    return makePublisher(
+        (segmentsToPublish) -> SegmentPublishResult.ok(Set.of())
+    );
   }
 
   private TransactionalSegmentPublisher makeUpgradingPublisher()
   {
-    return (segmentsToBeOverwritten, segmentsToPublish, commitMetadata, segmentSchemaMapping) -> {
+    return makePublisher((segmentsToPublish) -> {
       Set<DataSegment> allSegments = new HashSet<>(segmentsToPublish);
       int id = 0;
       for (DataSegment segment : segmentsToPublish) {
@@ -435,17 +438,36 @@ private TransactionalSegmentPublisher makeUpgradingPublisher()
         allSegments.add(upgradedSegment);
       }
       return SegmentPublishResult.ok(allSegments);
-    };
+    });
   }
 
   static TransactionalSegmentPublisher makeFailingPublisher(boolean failWithException)
   {
-    return (segmentsToBeOverwritten, segmentsToPublish, commitMetadata, segmentSchemaMapping) -> {
+    return makePublisher((segmentsToPublish) -> {
       final RuntimeException exception = new RuntimeException("test");
       if (failWithException) {
         throw exception;
       }
       return SegmentPublishResult.fail(exception.getMessage());
+    });
+  }
+
+  private static TransactionalSegmentPublisher makePublisher(
+      Function<Set<DataSegment>, SegmentPublishResult> publishFunction
+  )
+  {
+    return new TransactionalSegmentPublisher()
+    {
+      @Override
+      public SegmentPublishResult publishAnnotatedSegments(
+          @Nullable Set<DataSegment> segmentsToBeOverwritten,
+          Set<DataSegment> segmentsToPublish,
+          @Nullable Object commitMetadata,
+          @Nullable SegmentSchemaMapping segmentSchemaMapping
+      )
+      {
+        return publishFunction.apply(segmentsToPublish);
+      }
     };
   }
 
diff --git a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/TransactionalSegmentPublisherTest.java b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/TransactionalSegmentPublisherTest.java
new file mode 100644
index 000000000000..884b475893d1
--- /dev/null
+++ b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/TransactionalSegmentPublisherTest.java
@@ -0,0 +1,104 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import org.apache.druid.indexing.overlord.SegmentPublishResult;
+import org.apache.druid.segment.SegmentSchemaMapping;
+import org.apache.druid.timeline.DataSegment;
+import org.junit.Assert;
+import org.junit.Test;
+
+import javax.annotation.Nullable;
+import java.io.IOException;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+
+public class TransactionalSegmentPublisherTest
+{
+  @Test(timeout = 60_000L)
+  public void testPublishSegments_retriesUpto5Times_ifFailureIsRetryable() throws IOException
+  {
+    final AtomicInteger attemptCount = new AtomicInteger(0);
+    final TransactionalSegmentPublisher publisher = createPublisher(
+        SegmentPublishResult.retryableFailure("this error is retryable"),
+        attemptCount
+    );
+
+    Assert.assertEquals(
+        SegmentPublishResult.retryableFailure("this error is retryable"),
+        publisher.publishSegments(null, Set.of(), Function.identity(), null, null)
+    );
+    Assert.assertEquals(6, attemptCount.get());
+  }
+
+  @Test
+  public void testPublishSegments_doesNotRetry_ifFailureIsNotRetryable() throws IOException
+  {
+    final AtomicInteger attemptCount = new AtomicInteger(0);
+    final TransactionalSegmentPublisher publisher = createPublisher(
+        SegmentPublishResult.fail("this error is not retryable"),
+        attemptCount
+    );
+
+    Assert.assertEquals(
+        SegmentPublishResult.fail("this error is not retryable"),
+        publisher.publishSegments(null, Set.of(), Function.identity(), null, null)
+    );
+    Assert.assertEquals(1, attemptCount.get());
+  }
+
+  @Test
+  public void testPublishAnnotatedSegments_doesNotRetry() throws Exception
+  {
+    final AtomicInteger attemptCount = new AtomicInteger(0);
+    final TransactionalSegmentPublisher publisher = createPublisher(
+        SegmentPublishResult.retryableFailure("this error is retryable"),
+        attemptCount
+    );
+
+    Assert.assertEquals(
+        SegmentPublishResult.retryableFailure("this error is retryable"),
+        publisher.publishAnnotatedSegments(null, Set.of(), null, null)
+    );
+    Assert.assertEquals(1, attemptCount.get());
+  }
+
+  private TransactionalSegmentPublisher createPublisher(
+      SegmentPublishResult publishResult,
+      AtomicInteger attemptCount
+  )
+  {
+    return new TransactionalSegmentPublisher()
+    {
+      @Override
+      public SegmentPublishResult publishAnnotatedSegments(
+          @Nullable Set<DataSegment> segmentsToBeOverwritten,
+          Set<DataSegment> segmentsToPublish,
+          @Nullable Object commitMetadata,
+          @Nullable SegmentSchemaMapping segmentSchemaMapping
+      )
+      {
+        attemptCount.incrementAndGet();
+        return publishResult;
+      }
+    };
+  }
+}

From 11c6d049092b3f2c41a718f1c6197592bea5d6c0 Mon Sep 17 00:00:00 2001
From: Adarsh Sanjeev <adarshsanjeev@gmail.com>
Date: Mon, 24 Mar 2025 20:46:44 +0530
Subject: [PATCH 50/99] Add the capability to turboload segments onto
 historicals (#17775)

Add the capability to set Historicals into a turbo loading mode,
to focus on loading segments at the cost of query performance.

Context
--------
Currently, when a new Historical is started, it initially starts out using a bootstrap thread pool.
It uses this thread pool to load any existing cached segments and broadcast segments.
Once it loads any segments from both these sources, the historical switches to a smaller thread-pool
and begins to serve queries.

In certain cases, it would be useful to have the historical switch back to this mode,
and focus on loading segments, either to continue loading the initial non-bootstrap segments,
or to catch up with assigned segments.

This PR adds a coordinator dynamic config that allows servers to be configured to use
the larger bootstrap threadpool to load segments faster.

Changes
---------
- Added a new dynamic coordinator configuration, `turboLoadingNodes`.
- Ignore  `druid.coordinator.loadqueuepeon.http.batchSize` for servers in `turboLoadingNodes`
- Add API on historical to return loading capabilities i.e. num loading threads in normal and turbo mode
---
 .../dynamic-configuration-api.md              | 11 ++-
 docs/configuration/index.md                   |  3 +-
 .../DataSegmentChangeHandler.java             |  1 +
 .../coordination/SegmentLoadDropHandler.java  | 77 ++++++++++++---
 .../coordinator/CoordinatorDynamicConfig.java | 50 +++++++++-
 .../config/HttpLoadQueuePeonConfig.java       | 18 +++-
 .../loading/HttpLoadQueuePeon.java            | 93 ++++++++++++++++---
 .../loading/LoadQueueTaskMaster.java          | 17 +++-
 .../server/http/SegmentListerResource.java    | 31 ++++++-
 .../http/SegmentLoadingCapabilities.java      | 64 +++++++++++++
 .../druid/server/http/SegmentLoadingMode.java | 29 ++++++
 .../SegmentLoadDropHandlerTest.java           | 23 +++--
 .../DruidCoordinatorConfigTest.java           |  4 +-
 .../config/HttpLoadQueuePeonConfigTest.java   | 62 +++++++++++++
 .../loading/HttpLoadQueuePeonTest.java        | 43 ++++++++-
 .../CoordinatorSimulationBuilder.java         | 11 ++-
 .../TestSegmentLoadingHttpClient.java         | 27 ++++++
 .../http/CoordinatorDynamicConfigTest.java    | 78 +++++++++++-----
 .../http/SegmentLoadingCapabilitiesTest.java  | 52 +++++++++++
 .../org/apache/druid/cli/CliCoordinator.java  |  6 +-
 20 files changed, 613 insertions(+), 87 deletions(-)
 create mode 100644 server/src/main/java/org/apache/druid/server/http/SegmentLoadingCapabilities.java
 create mode 100644 server/src/main/java/org/apache/druid/server/http/SegmentLoadingMode.java
 create mode 100644 server/src/test/java/org/apache/druid/server/coordinator/config/HttpLoadQueuePeonConfigTest.java
 create mode 100644 server/src/test/java/org/apache/druid/server/http/SegmentLoadingCapabilitiesTest.java

diff --git a/docs/api-reference/dynamic-configuration-api.md b/docs/api-reference/dynamic-configuration-api.md
index 90b7028f2478..971aa81d206a 100644
--- a/docs/api-reference/dynamic-configuration-api.md
+++ b/docs/api-reference/dynamic-configuration-api.md
@@ -105,7 +105,8 @@ Host: http://ROUTER_IP:ROUTER_PORT
     "maxNonPrimaryReplicantsToLoad": 2147483647,
     "useRoundRobinSegmentAssignment": true,
     "smartSegmentLoading": true,
-    "debugDimensions": null
+    "debugDimensions": null,
+    "turboLoadingNodes": []
 }
 ```
 
@@ -172,7 +173,8 @@ curl "http://ROUTER_IP:ROUTER_PORT/druid/coordinator/v1/config" \
   "pauseCoordination": false,
   "replicateAfterLoadTimeout": false,
   "maxNonPrimaryReplicantsToLoad": 2147483647,
-  "useRoundRobinSegmentAssignment": true
+  "useRoundRobinSegmentAssignment": true,
+  "turboLoadingNodes": []
 }'
 ```
 
@@ -203,7 +205,8 @@ Content-Length: 683
   "pauseCoordination": false,
   "replicateAfterLoadTimeout": false,
   "maxNonPrimaryReplicantsToLoad": 2147483647,
-  "useRoundRobinSegmentAssignment": true
+  "useRoundRobinSegmentAssignment": true,
+  "turboLoadingNodes": []
 }
 ```
 
@@ -289,7 +292,7 @@ Host: http://ROUTER_IP:ROUTER_PORT
             "comment": "",
             "ip": "127.0.0.1"
         },
-        "payload": "{\"millisToWaitBeforeDeleting\":900000,\"maxSegmentsToMove\":5,\"replicantLifetime\":15,\"replicationThrottleLimit\":10,\"balancerComputeThreads\":1,\"killDataSourceWhitelist\":[],\"killPendingSegmentsSkipList\":[],\"maxSegmentsInNodeLoadingQueue\":100,\"decommissioningNodes\":[],\"decommissioningMaxPercentOfMaxSegmentsToMove\":70,\"pauseCoordination\":false,\"replicateAfterLoadTimeout\":false,\"maxNonPrimaryReplicantsToLoad\":2147483647,\"useRoundRobinSegmentAssignment\":true,\"smartSegmentLoading\":true,\"debugDimensions\":null}",
+        "payload": "{\"millisToWaitBeforeDeleting\":900000,\"maxSegmentsToMove\":5,\"replicantLifetime\":15,\"replicationThrottleLimit\":10,\"balancerComputeThreads\":1,\"killDataSourceWhitelist\":[],\"killPendingSegmentsSkipList\":[],\"maxSegmentsInNodeLoadingQueue\":100,\"decommissioningNodes\":[],\"decommissioningMaxPercentOfMaxSegmentsToMove\":70,\"pauseCoordination\":false,\"replicateAfterLoadTimeout\":false,\"maxNonPrimaryReplicantsToLoad\":2147483647,\"useRoundRobinSegmentAssignment\":true,\"smartSegmentLoading\":true,\"debugDimensions\":null,\"decommissioningNodes\":[]}",
         "auditTime": "2023-10-03T20:59:51.622Z"
     }
 ]
diff --git a/docs/configuration/index.md b/docs/configuration/index.md
index d75309b7ac31..687e1d688a67 100644
--- a/docs/configuration/index.md
+++ b/docs/configuration/index.md
@@ -885,7 +885,7 @@ These Coordinator static configurations can be defined in the `coordinator/runti
 |`druid.coordinator.kill.maxInterval`|The largest interval, as an [ISO 8601 duration](https://en.wikipedia.org/wiki/ISO_8601#Durations), of segments to delete per kill task. Set to zero, e.g. `PT0S`, for unlimited. This only applies when `druid.coordinator.kill.on=true`.|`P30D`|
 |`druid.coordinator.balancer.strategy`|The [balancing strategy](../design/coordinator.md#balancing-segments-in-a-tier) used by the Coordinator to distribute segments among the Historical servers in a tier. The `cost` strategy distributes segments by minimizing a cost function, `diskNormalized` weights these costs with the disk usage ratios of the servers and `random` distributes segments randomly.|`cost`|
 |`druid.coordinator.loadqueuepeon.http.repeatDelay`|The start and repeat delay (in milliseconds) for the load queue peon, which manages the load/drop queue of segments for any server.|1 minute|
-|`druid.coordinator.loadqueuepeon.http.batchSize`|Number of segment load/drop requests to batch in one HTTP request. Note that it must be smaller than `druid.segmentCache.numLoadingThreads` config on Historical service.|1|
+|`druid.coordinator.loadqueuepeon.http.batchSize`|Number of segment load/drop requests to batch in one HTTP request. Note that it must be smaller than or equal to the `druid.segmentCache.numLoadingThreads` config on Historical service. If this value is not configured, the coordinator uses the value of the `numLoadingThreads` for the respective server. | `druid.segmentCache.numLoadingThreads` |
 |`druid.coordinator.asOverlord.enabled`|Boolean value for whether this Coordinator service should act like an Overlord as well. This configuration allows users to simplify a Druid cluster by not having to deploy any standalone Overlord services. If set to true, then Overlord console is available at `http://coordinator-host:port/console.html` and be sure to set `druid.coordinator.asOverlord.overlordService` also.|false|
 |`druid.coordinator.asOverlord.overlordService`| Required, if `druid.coordinator.asOverlord.enabled` is `true`. This must be same value as `druid.service` on standalone Overlord services and `druid.selectors.indexing.serviceName` on Middle Managers.|NULL|
 
@@ -953,6 +953,7 @@ The following table shows the dynamic configuration properties for the Coordinat
 |`decommissioningNodes`|List of Historical servers to decommission. Coordinator will not assign new segments to decommissioning servers, and segments will be moved away from them to be placed on non-decommissioning servers at the maximum rate specified by `maxSegmentsToMove`.|none|
 |`pauseCoordination`|Boolean flag for whether or not the Coordinator should execute its various duties of coordinating the cluster. Setting this to true essentially pauses all coordination work while allowing the API to remain up. Duties that are paused include all classes that implement the `CoordinatorDuty` interface. Such duties include: segment balancing, segment compaction, submitting kill tasks for unused segments (if enabled), logging of used segments in the cluster, marking of newly unused or overshadowed segments, matching and execution of load/drop rules for used segments, unloading segments that are no longer marked as used from Historical servers. An example of when an admin may want to pause coordination would be if they are doing deep storage maintenance on HDFS name nodes with downtime and don't want the Coordinator to be directing Historical nodes to hit the name node with API requests until maintenance is done and the deep store is declared healthy for use again.|false|
 |`replicateAfterLoadTimeout`|Boolean flag for whether or not additional replication is needed for segments that have failed to load due to the expiry of `druid.coordinator.load.timeout`. If this is set to true, the Coordinator will attempt to replicate the failed segment on a different historical server. This helps improve the segment availability if there are a few slow Historicals in the cluster. However, the slow Historical may still load the segment later and the Coordinator may issue drop requests if the segment is over-replicated.|false|
+|`turboLoadingNodes`| List of Historical servers to place in turbo loading mode. These servers use a larger thread-pool to load segments faster but at the cost of query performance. For servers specified in `turboLoadingNodes`, `druid.coordinator.loadqueuepeon.http.batchSize` is ignored and the coordinator uses the value of the respective `numLoadingThreads` instead. |none|
 
 ##### Smart segment loading
 
diff --git a/server/src/main/java/org/apache/druid/server/coordination/DataSegmentChangeHandler.java b/server/src/main/java/org/apache/druid/server/coordination/DataSegmentChangeHandler.java
index cd2a8c3740f2..70758cd63abd 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/DataSegmentChangeHandler.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/DataSegmentChangeHandler.java
@@ -28,5 +28,6 @@
 public interface DataSegmentChangeHandler
 {
   void addSegment(DataSegment segment, @Nullable DataSegmentChangeCallback callback);
+
   void removeSegment(DataSegment segment, @Nullable DataSegmentChangeCallback callback);
 }
diff --git a/server/src/main/java/org/apache/druid/server/coordination/SegmentLoadDropHandler.java b/server/src/main/java/org/apache/druid/server/coordination/SegmentLoadDropHandler.java
index 12462adab2f6..4d3e22c1a131 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/SegmentLoadDropHandler.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/SegmentLoadDropHandler.java
@@ -33,6 +33,7 @@
 import org.apache.druid.segment.loading.SegmentLoaderConfig;
 import org.apache.druid.segment.loading.SegmentLoadingException;
 import org.apache.druid.server.SegmentManager;
+import org.apache.druid.server.http.SegmentLoadingMode;
 import org.apache.druid.server.metrics.SegmentRowCountDistribution;
 import org.apache.druid.timeline.DataSegment;
 
@@ -44,8 +45,11 @@
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentSkipListSet;
-import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
 
@@ -63,7 +67,8 @@ public class SegmentLoadDropHandler implements DataSegmentChangeHandler
   private final SegmentLoaderConfig config;
   private final DataSegmentAnnouncer announcer;
   private final SegmentManager segmentManager;
-  private final ScheduledExecutorService exec;
+  private final ScheduledExecutorService normalLoadExec;
+  private final ThreadPoolExecutor turboLoadExec;
 
   private final ConcurrentSkipListSet<DataSegment> segmentsToDelete;
 
@@ -88,9 +93,19 @@ public SegmentLoadDropHandler(
         config,
         announcer,
         segmentManager,
-        Executors.newScheduledThreadPool(
+        new ScheduledThreadPoolExecutor(
             config.getNumLoadingThreads(),
-            Execs.makeThreadFactory("SimpleDataSegmentChangeHandler-%s")
+            Execs.makeThreadFactory("SegmentLoadDropHandler-normal-%s")
+        ),
+        // Create a fixed size threadpool which has a timeout of 1 minute. Since they are all core threads, new threads
+        // will be created without enqueing the tasks till the capacity is reached.
+        new ThreadPoolExecutor(
+            config.getNumBootstrapThreads(),
+            config.getNumBootstrapThreads(),
+            60L,
+            TimeUnit.SECONDS,
+            new LinkedBlockingQueue<>(),
+            Execs.makeThreadFactory("SegmentLoadDropHandler-turbo-%s")
         )
     );
   }
@@ -100,13 +115,17 @@ public SegmentLoadDropHandler(
       SegmentLoaderConfig config,
       DataSegmentAnnouncer announcer,
       SegmentManager segmentManager,
-      ScheduledExecutorService exec
+      ScheduledExecutorService normalLoadExec,
+      ThreadPoolExecutor turboLoadExec
   )
   {
     this.config = config;
     this.announcer = announcer;
     this.segmentManager = segmentManager;
-    this.exec = exec;
+    this.normalLoadExec = normalLoadExec;
+    this.turboLoadExec = turboLoadExec;
+
+    this.turboLoadExec.allowCoreThreadTimeOut(true);
 
     this.segmentsToDelete = new ConcurrentSkipListSet<>();
     requestStatuses = CacheBuilder.newBuilder().maximumSize(config.getStatusQueueMaxSize()).initialCapacity(8).build();
@@ -214,7 +233,7 @@ void removeSegment(
             "Completely removing segment[%s] in [%,d]ms.",
             segment.getId(), config.getDropSegmentDelayMillis()
         );
-        exec.schedule(
+        normalLoadExec.schedule(
             runnable,
             config.getDropSegmentDelayMillis(),
             TimeUnit.MILLISECONDS
@@ -244,14 +263,22 @@ public Collection<DataSegment> getSegmentsToDelete()
     return ImmutableList.copyOf(segmentsToDelete);
   }
 
-  public ListenableFuture<List<DataSegmentChangeResponse>> processBatch(List<DataSegmentChangeRequest> changeRequests)
+  /**
+   * Process a list of {@link DataSegmentChangeRequest}, invoking
+   * {@link #processRequest(DataSegmentChangeRequest, SegmentLoadingMode)} for each one. Handles the computation
+   * asynchronously and returns a future to the result.
+   */
+  public ListenableFuture<List<DataSegmentChangeResponse>> processBatch(
+      List<DataSegmentChangeRequest> changeRequests,
+      SegmentLoadingMode segmentLoadingMode
+  )
   {
     boolean isAnyRequestDone = false;
 
     Map<DataSegmentChangeRequest, AtomicReference<SegmentChangeStatus>> statuses = Maps.newHashMapWithExpectedSize(changeRequests.size());
 
     for (DataSegmentChangeRequest cr : changeRequests) {
-      AtomicReference<SegmentChangeStatus> status = processRequest(cr);
+      AtomicReference<SegmentChangeStatus> status = processRequest(cr, segmentLoadingMode);
       if (status.get().getState() != SegmentChangeStatus.State.PENDING) {
         isAnyRequestDone = true;
       }
@@ -271,7 +298,15 @@ public ListenableFuture<List<DataSegmentChangeResponse>> processBatch(List<DataS
     return future;
   }
 
-  private AtomicReference<SegmentChangeStatus> processRequest(DataSegmentChangeRequest changeRequest)
+  /**
+   * Process a {@link DataSegmentChangeRequest}, invoking the request's
+   * {@link DataSegmentChangeRequest#go(DataSegmentChangeHandler, DataSegmentChangeCallback)}.
+   * The segmentLoadingMode parameter determines the thread pool to use.
+   */
+  private AtomicReference<SegmentChangeStatus> processRequest(
+      DataSegmentChangeRequest changeRequest,
+      SegmentLoadingMode segmentLoadingMode
+  )
   {
     synchronized (requestStatusesLock) {
       AtomicReference<SegmentChangeStatus> status = requestStatuses.getIfPresent(changeRequest);
@@ -282,10 +317,13 @@ private AtomicReference<SegmentChangeStatus> processRequest(DataSegmentChangeReq
             new DataSegmentChangeHandler()
             {
               @Override
-              public void addSegment(DataSegment segment, @Nullable DataSegmentChangeCallback callback)
+              public void addSegment(
+                  DataSegment segment,
+                  @Nullable DataSegmentChangeCallback callback
+              )
               {
                 requestStatuses.put(changeRequest, new AtomicReference<>(SegmentChangeStatus.PENDING));
-                exec.submit(
+                getExecutorService(segmentLoadingMode).submit(
                     () -> SegmentLoadDropHandler.this.addSegment(
                         ((SegmentChangeRequestLoad) changeRequest).getSegment(),
                         () -> resolveWaitingFutures()
@@ -294,7 +332,10 @@ public void addSegment(DataSegment segment, @Nullable DataSegmentChangeCallback
               }
 
               @Override
-              public void removeSegment(DataSegment segment, @Nullable DataSegmentChangeCallback callback)
+              public void removeSegment(
+                  DataSegment segment,
+                  @Nullable DataSegmentChangeCallback callback
+              )
               {
                 requestStatuses.put(changeRequest, new AtomicReference<>(SegmentChangeStatus.PENDING));
                 SegmentLoadDropHandler.this.removeSegment(
@@ -386,5 +427,15 @@ public boolean cancel(boolean interruptIfRunning)
       return true;
     }
   }
+
+  private ExecutorService getExecutorService(SegmentLoadingMode loadingMode)
+  {
+    return loadingMode == SegmentLoadingMode.TURBO ? turboLoadExec : normalLoadExec;
+  }
+
+  public SegmentLoaderConfig getSegmentLoaderConfig()
+  {
+    return config;
+  }
 }
 
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/CoordinatorDynamicConfig.java b/server/src/main/java/org/apache/druid/server/coordinator/CoordinatorDynamicConfig.java
index d805bad5e01c..806b6ebbee1e 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/CoordinatorDynamicConfig.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/CoordinatorDynamicConfig.java
@@ -23,10 +23,12 @@
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.collect.ImmutableSet;
+import org.apache.druid.common.config.Configs;
 import org.apache.druid.common.config.JacksonConfigManager;
 import org.apache.druid.error.InvalidInput;
 import org.apache.druid.server.coordinator.duty.KillUnusedSegments;
 import org.apache.druid.server.coordinator.stats.Dimension;
+import org.apache.druid.server.http.SegmentLoadingMode;
 import org.apache.druid.utils.JvmUtils;
 
 import javax.annotation.Nullable;
@@ -70,6 +72,8 @@ public class CoordinatorDynamicConfig
   private final Map<String, String> debugDimensions;
   private final Map<Dimension, String> validDebugDimensions;
 
+  private final Set<String> turboLoadingNodes;
+
   /**
    * Stale pending segments belonging to the data sources in this list are not killed by {@code
    * KillStalePendingSegments}. In other words, segments in these data sources are "protected".
@@ -118,7 +122,8 @@ public CoordinatorDynamicConfig(
       @JsonProperty("replicateAfterLoadTimeout") boolean replicateAfterLoadTimeout,
       @JsonProperty("useRoundRobinSegmentAssignment") @Nullable Boolean useRoundRobinSegmentAssignment,
       @JsonProperty("smartSegmentLoading") @Nullable Boolean smartSegmentLoading,
-      @JsonProperty("debugDimensions") @Nullable Map<String, String> debugDimensions
+      @JsonProperty("debugDimensions") @Nullable Map<String, String> debugDimensions,
+      @JsonProperty("turboLoadingNodes") @Nullable Set<String> turboLoadingNodes
   )
   {
     this.markSegmentAsUnusedDelayMillis =
@@ -162,6 +167,7 @@ public CoordinatorDynamicConfig(
     );
     this.debugDimensions = debugDimensions;
     this.validDebugDimensions = validateDebugDimensions(debugDimensions);
+    this.turboLoadingNodes = Configs.valueOrDefault(turboLoadingNodes, Set.of());
   }
 
   private Map<Dimension, String> validateDebugDimensions(Map<String, String> debugDimensions)
@@ -200,6 +206,13 @@ private static Set<String> parseJsonStringOrArray(Object jsonStringOrArray)
     }
   }
 
+  public SegmentLoadingMode getLoadingModeForServer(String serverName)
+  {
+    return turboLoadingNodes.contains(serverName) ?
+           SegmentLoadingMode.TURBO :
+           SegmentLoadingMode.NORMAL;
+  }
+
   @JsonProperty("millisToWaitBeforeDeleting")
   public long getMarkSegmentAsUnusedDelayMillis()
   {
@@ -308,6 +321,19 @@ public boolean getReplicateAfterLoadTimeout()
     return replicateAfterLoadTimeout;
   }
 
+  /**
+   * List of servers to put in turbo-loading mode. These servers will use a larger thread pool to load
+   * segments. This causes decreases the average time taken to load segments. However, this also means less resources
+   * available to query threads which may cause a drop in query performance.
+   *
+   * @return Set of host:port entries
+   */
+  @JsonProperty
+  public Set<String> getTurboLoadingNodes()
+  {
+    return turboLoadingNodes;
+  }
+
   @Override
   public String toString()
   {
@@ -326,6 +352,7 @@ public String toString()
            ", decommissioningNodes=" + decommissioningNodes +
            ", pauseCoordination=" + pauseCoordination +
            ", replicateAfterLoadTimeout=" + replicateAfterLoadTimeout +
+           ", turboLoadingNodes=" + turboLoadingNodes +
            '}';
   }
 
@@ -359,6 +386,7 @@ public boolean equals(Object o)
                dataSourcesToNotKillStalePendingSegmentsIn,
                that.dataSourcesToNotKillStalePendingSegmentsIn)
            && Objects.equals(decommissioningNodes, that.decommissioningNodes)
+           && Objects.equals(turboLoadingNodes, that.turboLoadingNodes)
            && Objects.equals(debugDimensions, that.debugDimensions);
   }
 
@@ -378,7 +406,8 @@ public int hashCode()
         dataSourcesToNotKillStalePendingSegmentsIn,
         decommissioningNodes,
         pauseCoordination,
-        debugDimensions
+        debugDimensions,
+        turboLoadingNodes
     );
   }
 
@@ -430,6 +459,7 @@ public static class Builder
     private Boolean replicateAfterLoadTimeout;
     private Boolean useRoundRobinSegmentAssignment;
     private Boolean smartSegmentLoading;
+    private Set<String> turboLoadingNodes;
 
     public Builder()
     {
@@ -452,7 +482,8 @@ public Builder(
         @JsonProperty("replicateAfterLoadTimeout") @Nullable Boolean replicateAfterLoadTimeout,
         @JsonProperty("useRoundRobinSegmentAssignment") @Nullable Boolean useRoundRobinSegmentAssignment,
         @JsonProperty("smartSegmentLoading") @Nullable Boolean smartSegmentLoading,
-        @JsonProperty("debugDimensions") @Nullable Map<String, String> debugDimensions
+        @JsonProperty("debugDimensions") @Nullable Map<String, String> debugDimensions,
+        @JsonProperty("turboLoadingNodes") @Nullable Set<String> turboLoadingNodes
     )
     {
       this.markSegmentAsUnusedDelayMillis = markSegmentAsUnusedDelayMillis;
@@ -471,6 +502,7 @@ public Builder(
       this.useRoundRobinSegmentAssignment = useRoundRobinSegmentAssignment;
       this.smartSegmentLoading = smartSegmentLoading;
       this.debugDimensions = debugDimensions;
+      this.turboLoadingNodes = turboLoadingNodes;
     }
 
     public Builder withMarkSegmentAsUnusedDelayMillis(long leadingTimeMillis)
@@ -491,6 +523,12 @@ public Builder withSmartSegmentLoading(boolean smartSegmentLoading)
       return this;
     }
 
+    public Builder withTurboLoadingNodes(Set<String> turboLoadingNodes)
+    {
+      this.turboLoadingNodes = turboLoadingNodes;
+      return this;
+    }
+
     public Builder withReplicantLifetime(int replicantLifetime)
     {
       this.replicantLifetime = replicantLifetime;
@@ -582,7 +620,8 @@ public CoordinatorDynamicConfig build()
           valueOrDefault(replicateAfterLoadTimeout, Defaults.REPLICATE_AFTER_LOAD_TIMEOUT),
           valueOrDefault(useRoundRobinSegmentAssignment, Defaults.USE_ROUND_ROBIN_ASSIGNMENT),
           valueOrDefault(smartSegmentLoading, Defaults.SMART_SEGMENT_LOADING),
-          debugDimensions
+          debugDimensions,
+          turboLoadingNodes
       );
     }
 
@@ -612,7 +651,8 @@ public CoordinatorDynamicConfig build(CoordinatorDynamicConfig defaults)
           valueOrDefault(replicateAfterLoadTimeout, defaults.getReplicateAfterLoadTimeout()),
           valueOrDefault(useRoundRobinSegmentAssignment, defaults.isUseRoundRobinSegmentAssignment()),
           valueOrDefault(smartSegmentLoading, defaults.isSmartSegmentLoading()),
-          valueOrDefault(debugDimensions, defaults.getDebugDimensions())
+          valueOrDefault(debugDimensions, defaults.getDebugDimensions()),
+          valueOrDefault(turboLoadingNodes, defaults.getTurboLoadingNodes())
       );
     }
   }
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/config/HttpLoadQueuePeonConfig.java b/server/src/main/java/org/apache/druid/server/coordinator/config/HttpLoadQueuePeonConfig.java
index f6f402037d1f..42af2e948cf8 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/config/HttpLoadQueuePeonConfig.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/config/HttpLoadQueuePeonConfig.java
@@ -22,8 +22,11 @@
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import org.apache.druid.common.config.Configs;
+import org.apache.druid.java.util.common.RE;
 import org.joda.time.Duration;
 
+import javax.annotation.Nullable;
+
 public class HttpLoadQueuePeonConfig
 {
   private static final Duration DEFAULT_LOAD_TIMEOUT = Duration.standardMinutes(15);
@@ -35,21 +38,28 @@ public class HttpLoadQueuePeonConfig
   private final Duration repeatDelay;
 
   @JsonProperty
-  private final int batchSize;
+  @Nullable
+  private final Integer batchSize;
 
   @JsonCreator
   public HttpLoadQueuePeonConfig(
       @JsonProperty("hostTimeout") Duration hostTimeout,
       @JsonProperty("repeatDelay") Duration repeatDelay,
-      @JsonProperty("batchSize") Integer batchSize
+      @JsonProperty("batchSize") @Nullable Integer batchSize
   )
   {
     this.hostTimeout = Configs.valueOrDefault(hostTimeout, Duration.standardMinutes(5));
     this.repeatDelay = Configs.valueOrDefault(repeatDelay, Duration.standardMinutes(1));
-    this.batchSize = Configs.valueOrDefault(batchSize, 1);
+
+    if (batchSize != null && batchSize < 1) {
+      throw new RE("Batch size must be greater than 0.");
+    }
+
+    this.batchSize = batchSize;
   }
 
-  public int getBatchSize()
+  @Nullable
+  public Integer getBatchSize()
   {
     return batchSize;
   }
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeon.java b/server/src/main/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeon.java
index 015b5686769d..4f5ff04911ed 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeon.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeon.java
@@ -22,9 +22,11 @@
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.ObjectWriter;
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.druid.common.config.Configs;
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.RE;
 import org.apache.druid.java.util.common.StringUtils;
@@ -45,6 +47,8 @@
 import org.apache.druid.server.coordinator.stats.Dimension;
 import org.apache.druid.server.coordinator.stats.RowKey;
 import org.apache.druid.server.coordinator.stats.Stats;
+import org.apache.druid.server.http.SegmentLoadingCapabilities;
+import org.apache.druid.server.http.SegmentLoadingMode;
 import org.apache.druid.timeline.DataSegment;
 import org.jboss.netty.handler.codec.http.HttpHeaders;
 import org.jboss.netty.handler.codec.http.HttpMethod;
@@ -53,7 +57,6 @@
 import javax.servlet.http.HttpServletResponse;
 import javax.ws.rs.core.MediaType;
 import java.io.InputStream;
-import java.net.MalformedURLException;
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -69,6 +72,7 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Supplier;
 
 /**
  *
@@ -82,6 +86,7 @@ public class HttpLoadQueuePeon implements LoadQueuePeon
       new TypeReference<>() {};
 
   private static final EmittingLogger log = new EmittingLogger(HttpLoadQueuePeon.class);
+  private static final long DEFAULT_TIMEOUT = 10000L;
 
   private final AtomicLong queuedSize = new AtomicLong(0);
   private final AtomicReference<CoordinatorRunStats> stats = new AtomicReference<>(new CoordinatorRunStats());
@@ -114,19 +119,21 @@ public class HttpLoadQueuePeon implements LoadQueuePeon
 
   private final ObjectMapper jsonMapper;
   private final HttpClient httpClient;
-  private final URL changeRequestURL;
   private final String serverId;
 
   private final AtomicBoolean mainLoopInProgress = new AtomicBoolean(false);
   private final ExecutorService callBackExecutor;
+  private final Supplier<SegmentLoadingMode> loadingModeSupplier;
 
   private final ObjectWriter requestBodyWriter;
+  private final SegmentLoadingCapabilities serverCapabilities;
 
   public HttpLoadQueuePeon(
       String baseUrl,
       ObjectMapper jsonMapper,
       HttpClient httpClient,
       HttpLoadQueuePeonConfig config,
+      Supplier<SegmentLoadingMode> loadingModeSupplier,
       ScheduledExecutorService processingExecutor,
       ExecutorService callBackExecutor
   )
@@ -139,17 +146,48 @@ public HttpLoadQueuePeon(
     this.callBackExecutor = callBackExecutor;
 
     this.serverId = baseUrl;
+    this.loadingModeSupplier = loadingModeSupplier;
+    this.serverCapabilities = fetchSegmentLoadingCapabilities();
+  }
+
+  @VisibleForTesting
+  SegmentLoadingCapabilities fetchSegmentLoadingCapabilities()
+  {
     try {
-      this.changeRequestURL = new URL(
-          new URL(baseUrl),
-          StringUtils.nonStrictFormat(
-              "druid-internal/v1/segments/changeRequests?timeout=%d",
-              config.getHostTimeout().getMillis()
-          )
+      final URL segmentLoadingCapabilitiesURL = new URL(
+          new URL(serverId),
+          "druid-internal/v1/segments/loadCapabilities"
+      );
+
+      BytesAccumulatingResponseHandler responseHandler = new BytesAccumulatingResponseHandler();
+      InputStream stream = httpClient.go(
+          new Request(HttpMethod.GET, segmentLoadingCapabilitiesURL)
+              .addHeader(HttpHeaders.Names.ACCEPT, MediaType.APPLICATION_JSON),
+          responseHandler,
+          new Duration(DEFAULT_TIMEOUT)
+      ).get();
+
+      if (HttpServletResponse.SC_NOT_FOUND == responseHandler.getStatus()) {
+        int batchSize = config.getBatchSize() == null ? 1 : config.getBatchSize();
+        SegmentLoadingCapabilities defaultCapabilities = new SegmentLoadingCapabilities(batchSize, batchSize);
+        log.warn(
+            "Historical capabilities endpoint not found at URL[%s]. Using default values[%s].",
+            segmentLoadingCapabilitiesURL,
+            defaultCapabilities
+        );
+        return defaultCapabilities;
+      } else if (HttpServletResponse.SC_OK != responseHandler.getStatus()) {
+        log.makeAlert("Received status[%s] when fetching loading capabilities from server[%s]", responseHandler.getStatus(), serverId);
+        throw new RE("Received status[%s] when fetching loading capabilities from server[%s]", responseHandler.getStatus(), serverId);
+      }
+
+      return jsonMapper.readValue(
+          stream,
+          SegmentLoadingCapabilities.class
       );
     }
-    catch (MalformedURLException ex) {
-      throw new RuntimeException(ex);
+    catch (Throwable th) {
+      throw new RE(th, "Received error while fetching historical capabilities from Server[%s].", serverId);
     }
   }
 
@@ -160,7 +198,8 @@ private void doSegmentManagement()
       return;
     }
 
-    final int batchSize = config.getBatchSize();
+    final SegmentLoadingMode loadingMode = loadingModeSupplier.get();
+    final int batchSize = calculateBatchSize(loadingMode);
 
     final List<DataSegmentChangeRequest> newRequests = new ArrayList<>(batchSize);
 
@@ -194,19 +233,28 @@ private void doSegmentManagement()
     if (newRequests.isEmpty()) {
       log.trace(
           "[%s]Found no load/drop requests. SegmentsToLoad[%d], SegmentsToDrop[%d], batchSize[%d].",
-          serverId, segmentsToLoad.size(), segmentsToDrop.size(), config.getBatchSize()
+          serverId, segmentsToLoad.size(), segmentsToDrop.size(), batchSize
       );
       mainLoopInProgress.set(false);
       return;
     }
 
     try {
-      log.trace("Sending [%d] load/drop requests to Server[%s].", newRequests.size(), serverId);
+      log.trace("Sending [%d] load/drop requests to Server[%s] in loadingMode[%s].", newRequests.size(), serverId, loadingMode);
       final boolean hasLoadRequests = newRequests.stream().anyMatch(r -> r instanceof SegmentChangeRequestLoad);
       if (hasLoadRequests && !loadingRateTracker.isLoadingBatch()) {
         loadingRateTracker.markBatchLoadingStarted();
       }
 
+      final URL changeRequestURL = new URL(
+          new URL(serverId),
+          StringUtils.nonStrictFormat(
+              "druid-internal/v1/segments/changeRequests?timeout=%d&loadingMode=%s",
+              config.getHostTimeout().getMillis(),
+              loadingMode
+          )
+      );
+
       BytesAccumulatingResponseHandler responseHandler = new BytesAccumulatingResponseHandler();
       ListenableFuture<InputStream> future = httpClient.go(
           new Request(HttpMethod.POST, changeRequestURL)
@@ -314,6 +362,25 @@ private void logRequestFailure(Throwable t)
     }
   }
 
+  /**
+   * Calculates the number of segments the server is capable of handling at a time. If loading segments in turbo loading
+   * mode, returns the number of turbo loading threads on the server. Otherwise, return the value set by the batch size
+   * runtime parameter, or number of normal threads on the server if the parameter is not set.
+   * Always returns a positive integer.
+   */
+  @VisibleForTesting
+  int calculateBatchSize(SegmentLoadingMode loadingMode)
+  {
+    int batchSize;
+    if (SegmentLoadingMode.TURBO.equals(loadingMode)) {
+      batchSize = serverCapabilities.getNumTurboLoadingThreads();
+    } else {
+      batchSize = Configs.valueOrDefault(config.getBatchSize(), serverCapabilities.getNumLoadingThreads());
+    }
+
+    return Math.max(batchSize, 1);
+  }
+
   private void handleResponseStatus(DataSegmentChangeRequest changeRequest, SegmentChangeStatus status)
   {
     changeRequest.go(
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/loading/LoadQueueTaskMaster.java b/server/src/main/java/org/apache/druid/server/coordinator/loading/LoadQueueTaskMaster.java
index ed6d2d5a3ea3..d9fdca36c67d 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/loading/LoadQueueTaskMaster.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/loading/LoadQueueTaskMaster.java
@@ -25,6 +25,7 @@
 import org.apache.druid.client.ImmutableDruidServer;
 import org.apache.druid.java.util.common.logger.Logger;
 import org.apache.druid.java.util.http.client.HttpClient;
+import org.apache.druid.server.coordinator.CoordinatorDynamicConfig;
 import org.apache.druid.server.coordinator.config.HttpLoadQueuePeonConfig;
 
 import java.util.List;
@@ -34,6 +35,7 @@
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Supplier;
 
 /**
  * Provides LoadQueuePeons
@@ -47,6 +49,7 @@ public class LoadQueueTaskMaster
   private final ExecutorService callbackExec;
   private final HttpLoadQueuePeonConfig config;
   private final HttpClient httpClient;
+  private final Supplier<CoordinatorDynamicConfig> coordinatorDynamicConfigSupplier;
 
   @GuardedBy("this")
   private final AtomicBoolean isLeader = new AtomicBoolean(false);
@@ -58,7 +61,8 @@ public LoadQueueTaskMaster(
       ScheduledExecutorService peonExec,
       ExecutorService callbackExec,
       HttpLoadQueuePeonConfig config,
-      HttpClient httpClient
+      HttpClient httpClient,
+      Supplier<CoordinatorDynamicConfig> coordinatorDynamicConfigSupplier
   )
   {
     this.jsonMapper = jsonMapper;
@@ -66,11 +70,20 @@ public LoadQueueTaskMaster(
     this.callbackExec = callbackExec;
     this.config = config;
     this.httpClient = httpClient;
+    this.coordinatorDynamicConfigSupplier = coordinatorDynamicConfigSupplier;
   }
 
   private LoadQueuePeon createPeon(ImmutableDruidServer server)
   {
-    return new HttpLoadQueuePeon(server.getURL(), jsonMapper, httpClient, config, peonExec, callbackExec);
+    return new HttpLoadQueuePeon(
+        server.getURL(),
+        jsonMapper,
+        httpClient,
+        config,
+        () -> coordinatorDynamicConfigSupplier.get().getLoadingModeForServer(server.getName()),
+        peonExec,
+        callbackExec
+    );
   }
 
   public Map<String, LoadQueuePeon> getAllPeons()
diff --git a/server/src/main/java/org/apache/druid/server/http/SegmentListerResource.java b/server/src/main/java/org/apache/druid/server/http/SegmentListerResource.java
index 7c4392daf4e2..48e037271995 100644
--- a/server/src/main/java/org/apache/druid/server/http/SegmentListerResource.java
+++ b/server/src/main/java/org/apache/druid/server/http/SegmentListerResource.java
@@ -31,6 +31,7 @@
 import org.apache.druid.guice.annotations.Json;
 import org.apache.druid.guice.annotations.Smile;
 import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.segment.loading.SegmentLoaderConfig;
 import org.apache.druid.server.coordination.BatchDataSegmentAnnouncer;
 import org.apache.druid.server.coordination.ChangeRequestHistory;
 import org.apache.druid.server.coordination.ChangeRequestsSnapshot;
@@ -54,6 +55,7 @@
 import javax.ws.rs.QueryParam;
 import javax.ws.rs.core.Context;
 import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
 import java.io.IOException;
 import java.util.List;
 
@@ -219,10 +221,10 @@ public void onFailure(Throwable th)
    * This endpoint is used by HttpLoadQueuePeon to assign segment load/drop requests batch. This endpoint makes the
    * client wait till one of the following events occur. Note that this is implemented using async IO so no jetty
    * threads are held while in wait.
-   *
-   * (1) Given timeout elapses.
-   * (2) Some load/drop request completed.
-   *
+   * <ol>
+   *   <li>Given timeout elapses.</li>
+   *   <li>Some load/drop request completed.</li>
+   * </ol>
    * It returns a map of "load/drop request -> SUCCESS/FAILED/PENDING status" for each request in the batch.
    */
   @POST
@@ -231,6 +233,7 @@ public void onFailure(Throwable th)
   @Consumes({MediaType.APPLICATION_JSON, SmileMediaTypes.APPLICATION_JACKSON_SMILE})
   public void applyDataSegmentChangeRequests(
       @QueryParam("timeout") long timeout,
+      @QueryParam("loadingMode") @Nullable SegmentLoadingMode loadingMode,
       List<DataSegmentChangeRequest> changeRequestList,
       @Context final HttpServletRequest req
   ) throws IOException
@@ -252,7 +255,7 @@ public void applyDataSegmentChangeRequests(
 
     final ResponseContext context = createContext(req.getHeader("Accept"));
     final ListenableFuture<List<DataSegmentChangeResponse>> future =
-        loadDropRequestHandler.processBatch(changeRequestList);
+        loadDropRequestHandler.processBatch(changeRequestList, loadingMode == null ? SegmentLoadingMode.NORMAL : loadingMode);
 
     final AsyncContext asyncContext = req.startAsync();
 
@@ -327,6 +330,24 @@ public void onFailure(Throwable th)
     asyncContext.setTimeout(timeout);
   }
 
+  @GET
+  @Path("/loadCapabilities")
+  @Produces({MediaType.APPLICATION_JSON, SmileMediaTypes.APPLICATION_JACKSON_SMILE})
+  public Response getSegmentLoadingCapabilities(
+      @Context final HttpServletRequest req
+  )
+  {
+    if (loadDropRequestHandler == null) {
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
+    }
+
+    SegmentLoaderConfig config = loadDropRequestHandler.getSegmentLoaderConfig();
+    SegmentLoadingCapabilities capabilitiesResponse =
+        new SegmentLoadingCapabilities(config.getNumLoadingThreads(), config.getNumBootstrapThreads());
+
+    return Response.status(Response.Status.OK).entity(capabilitiesResponse).build();
+  }
+
   private void sendErrorResponse(HttpServletRequest req, int code, String error) throws IOException
   {
     AsyncContext asyncContext = req.startAsync();
diff --git a/server/src/main/java/org/apache/druid/server/http/SegmentLoadingCapabilities.java b/server/src/main/java/org/apache/druid/server/http/SegmentLoadingCapabilities.java
new file mode 100644
index 000000000000..9dba8af5e6bb
--- /dev/null
+++ b/server/src/main/java/org/apache/druid/server/http/SegmentLoadingCapabilities.java
@@ -0,0 +1,64 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.server.http;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+/**
+ * Contains information related to the capability of a server to load segments, for example the number of threads
+ * available.
+ */
+public class SegmentLoadingCapabilities
+{
+  private final int numLoadingThreads;
+  private final int numTurboLoadingThreads;
+
+  @JsonCreator
+  public SegmentLoadingCapabilities(
+      @JsonProperty("numLoadingThreads") int numLoadingThreads,
+      @JsonProperty("numTurboLoadingThreads") int numTurboLoadingThreads
+  )
+  {
+    this.numLoadingThreads = numLoadingThreads;
+    this.numTurboLoadingThreads = numTurboLoadingThreads;
+  }
+
+  @JsonProperty("numLoadingThreads")
+  public int getNumLoadingThreads()
+  {
+    return numLoadingThreads;
+  }
+
+  @JsonProperty("numTurboLoadingThreads")
+  public int getNumTurboLoadingThreads()
+  {
+    return numTurboLoadingThreads;
+  }
+
+  @Override
+  public String toString()
+  {
+    return "SegmentLoadingCapabilities{" +
+           "numLoadingThreads=" + numLoadingThreads +
+           ", numTurboLoadingThreads=" + numTurboLoadingThreads +
+           '}';
+  }
+}
diff --git a/server/src/main/java/org/apache/druid/server/http/SegmentLoadingMode.java b/server/src/main/java/org/apache/druid/server/http/SegmentLoadingMode.java
new file mode 100644
index 000000000000..b3896a540bda
--- /dev/null
+++ b/server/src/main/java/org/apache/druid/server/http/SegmentLoadingMode.java
@@ -0,0 +1,29 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.server.http;
+
+/**
+ * Determines the threadpool used by the historical to load segments.
+ */
+public enum SegmentLoadingMode
+{
+  NORMAL,
+  TURBO
+}
diff --git a/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java b/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
index cd2fe2dbd63e..7a8822a60d87 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
@@ -30,6 +30,7 @@
 import org.apache.druid.segment.loading.StorageLocationConfig;
 import org.apache.druid.server.SegmentManager;
 import org.apache.druid.server.coordination.SegmentChangeStatus.State;
+import org.apache.druid.server.http.SegmentLoadingMode;
 import org.apache.druid.timeline.DataSegment;
 import org.junit.Assert;
 import org.junit.Before;
@@ -48,6 +49,7 @@
 import java.util.Map;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 
 import static org.apache.druid.server.TestSegmentUtils.makeSegment;
@@ -106,7 +108,7 @@ public int getDropSegmentDelayMillis()
 
     scheduledExecutorFactory = (corePoolSize, nameFormat) -> {
       // Override normal behavior by adding the runnable to a list so that you can make sure
-      // all the shceduled runnables are executed by explicitly calling run() on each item in the list
+      // all the scheduled runnables are executed by explicitly calling run() on each item in the list
       return new ScheduledThreadPoolExecutor(corePoolSize, Execs.makeThreadFactory(nameFormat))
       {
         @Override
@@ -230,7 +232,7 @@ public void testProcessBatch() throws Exception
         new SegmentChangeRequestDrop(segment2)
     );
 
-    ListenableFuture<List<DataSegmentChangeResponse>> future = handler.processBatch(batch);
+    ListenableFuture<List<DataSegmentChangeResponse>> future = handler.processBatch(batch, SegmentLoadingMode.NORMAL);
 
     Map<DataSegmentChangeRequest, SegmentChangeStatus> expectedStatusMap = new HashMap<>();
     expectedStatusMap.put(batch.get(0), SegmentChangeStatus.PENDING);
@@ -244,7 +246,7 @@ public void testProcessBatch() throws Exception
       runnable.run();
     }
 
-    result = handler.processBatch(ImmutableList.of(new SegmentChangeRequestLoad(segment1))).get();
+    result = handler.processBatch(ImmutableList.of(new SegmentChangeRequestLoad(segment1)), SegmentLoadingMode.TURBO).get();
     Assert.assertEquals(SegmentChangeStatus.SUCCESS, result.get(0).getStatus());
 
     Assert.assertEquals(ImmutableList.of(segment1), segmentAnnouncer.getObservedSegments());
@@ -271,7 +273,7 @@ public void testProcessBatchDuplicateLoadRequestsWhenFirstRequestFailsSecondRequ
     DataSegment segment1 = makeSegment("batchtest1", "1", Intervals.of("P1d/2011-04-01"));
     List<DataSegmentChangeRequest> batch = ImmutableList.of(new SegmentChangeRequestLoad(segment1));
 
-    ListenableFuture<List<DataSegmentChangeResponse>> future = handler.processBatch(batch);
+    ListenableFuture<List<DataSegmentChangeResponse>> future = handler.processBatch(batch, SegmentLoadingMode.NORMAL);
 
     for (Runnable runnable : scheduledRunnable) {
       runnable.run();
@@ -280,7 +282,7 @@ public void testProcessBatchDuplicateLoadRequestsWhenFirstRequestFailsSecondRequ
     Assert.assertEquals(State.FAILED, result.get(0).getStatus().getState());
     Assert.assertEquals(ImmutableList.of(), segmentAnnouncer.getObservedSegments());
 
-    future = handler.processBatch(batch);
+    future = handler.processBatch(batch, SegmentLoadingMode.NORMAL);
     for (Runnable runnable : scheduledRunnable) {
       runnable.run();
     }
@@ -343,7 +345,7 @@ public int getDropSegmentDelayMillis()
     List<DataSegmentChangeRequest> batch = ImmutableList.of(new SegmentChangeRequestLoad(segment1));
 
     // Request 1: Load the segment
-    ListenableFuture<List<DataSegmentChangeResponse>> future = handler.processBatch(batch);
+    ListenableFuture<List<DataSegmentChangeResponse>> future = handler.processBatch(batch, SegmentLoadingMode.NORMAL);
     for (Runnable runnable : scheduledRunnable) {
       runnable.run();
     }
@@ -354,7 +356,7 @@ public int getDropSegmentDelayMillis()
 
     // Request 2: Drop the segment
     batch = ImmutableList.of(new SegmentChangeRequestDrop(segment1));
-    future = handler.processBatch(batch);
+    future = handler.processBatch(batch, SegmentLoadingMode.NORMAL);
     for (Runnable runnable : scheduledRunnable) {
       runnable.run();
     }
@@ -372,7 +374,7 @@ public int getDropSegmentDelayMillis()
 
     // Request 3: Reload the segment
     batch = ImmutableList.of(new SegmentChangeRequestLoad(segment1));
-    future = handler.processBatch(batch);
+    future = handler.processBatch(batch, SegmentLoadingMode.NORMAL);
     for (Runnable runnable : scheduledRunnable) {
       runnable.run();
     }
@@ -389,7 +391,7 @@ public int getDropSegmentDelayMillis()
 
     // Request 4: Try to reload the segment - segment is loaded and announced again
     batch = ImmutableList.of(new SegmentChangeRequestLoad(segment1));
-    future = handler.processBatch(batch);
+    future = handler.processBatch(batch, SegmentLoadingMode.NORMAL);
     for (Runnable runnable : scheduledRunnable) {
       runnable.run();
     }
@@ -420,7 +422,8 @@ private SegmentLoadDropHandler initSegmentLoadDropHandler(
         config,
         segmentAnnouncer,
         segmentManager,
-        scheduledExecutorFactory.create(5, "SegmentLoadDropHandlerTest-[%d]")
+        scheduledExecutorFactory.create(5, "LoadDropHandlerTest-[%d]"),
+        (ThreadPoolExecutor) scheduledExecutorFactory.create(5, "TurboSegmentLoadDropHandlerTest-[%d]")
     );
   }
 }
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorConfigTest.java b/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorConfigTest.java
index 36cb9c8439f4..d91cb62050a1 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorConfigTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorConfigTest.java
@@ -101,7 +101,7 @@ public void testLoadQueuePeonConfigDefaultValues()
     Assert.assertEquals(Duration.standardMinutes(1), config.getRepeatDelay());
     Assert.assertEquals(Duration.standardMinutes(5), config.getHostTimeout());
     Assert.assertEquals(Duration.standardMinutes(15), config.getLoadTimeout());
-    Assert.assertEquals(1, config.getBatchSize());
+    Assert.assertNull(config.getBatchSize());
   }
 
   @Test
@@ -118,7 +118,7 @@ public void testLoadQueuePeonConfigOverrideValues()
     Assert.assertEquals(Duration.standardMinutes(20), config.getRepeatDelay());
     Assert.assertEquals(Duration.standardMinutes(10), config.getHostTimeout());
     Assert.assertEquals(Duration.standardMinutes(15), config.getLoadTimeout());
-    Assert.assertEquals(100, config.getBatchSize());
+    Assert.assertEquals(Integer.valueOf(100), config.getBatchSize());
   }
 
   @Test
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/config/HttpLoadQueuePeonConfigTest.java b/server/src/test/java/org/apache/druid/server/coordinator/config/HttpLoadQueuePeonConfigTest.java
new file mode 100644
index 000000000000..4d9a2400215c
--- /dev/null
+++ b/server/src/test/java/org/apache/druid/server/coordinator/config/HttpLoadQueuePeonConfigTest.java
@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.server.coordinator.config;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.exc.ValueInstantiationException;
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.MatcherAssert;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.internal.matchers.ThrowableMessageMatcher;
+
+public class HttpLoadQueuePeonConfigTest
+{
+  @Test
+  public void testValidateBatchSize() throws JsonProcessingException
+  {
+    ObjectMapper jsonMapper = new ObjectMapper();
+
+    MatcherAssert.assertThat(
+        Assert.assertThrows(ValueInstantiationException.class, () ->
+            jsonMapper.readValue("{\"batchSize\":0}", HttpLoadQueuePeonConfig.class)
+        ),
+        CoreMatchers.allOf(
+            CoreMatchers.instanceOf(ValueInstantiationException.class),
+            ThrowableMessageMatcher.hasMessage(
+                CoreMatchers.containsString("Batch size must be greater than 0.")
+            )
+        )
+    );
+
+    HttpLoadQueuePeonConfig emptyConfig = jsonMapper.readValue(
+        "{}",
+        HttpLoadQueuePeonConfig.class
+    );
+    Assert.assertNull(emptyConfig.getBatchSize());
+
+    HttpLoadQueuePeonConfig config = jsonMapper.readValue(
+        "{\"batchSize\":2}",
+        HttpLoadQueuePeonConfig.class
+    );
+    Assert.assertEquals(2, config.getBatchSize().intValue());
+  }
+}
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeonTest.java b/server/src/test/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeonTest.java
index 1dcf384d2e0d..e511ce77ee2c 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeonTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeonTest.java
@@ -37,6 +37,8 @@
 import org.apache.druid.server.coordinator.config.HttpLoadQueuePeonConfig;
 import org.apache.druid.server.coordinator.simulate.BlockingExecutorService;
 import org.apache.druid.server.coordinator.simulate.WrappingScheduledExecutorService;
+import org.apache.druid.server.http.SegmentLoadingCapabilities;
+import org.apache.druid.server.http.SegmentLoadingMode;
 import org.apache.druid.timeline.DataSegment;
 import org.jboss.netty.buffer.ChannelBuffers;
 import org.jboss.netty.handler.codec.http.DefaultHttpResponse;
@@ -81,13 +83,21 @@ public void setUp()
         MAPPER,
         httpClient,
         new HttpLoadQueuePeonConfig(null, null, 10),
+        () -> SegmentLoadingMode.NORMAL,
         new WrappingScheduledExecutorService(
             "HttpLoadQueuePeonTest-%s",
             httpClient.processingExecutor,
             true
         ),
         httpClient.callbackExecutor
-    );
+    )
+    {
+      @Override
+      SegmentLoadingCapabilities fetchSegmentLoadingCapabilities()
+      {
+        return new SegmentLoadingCapabilities(1, 3);
+      }
+    };
     httpLoadQueuePeon.start();
   }
 
@@ -316,6 +326,37 @@ public void testLoadRateIsChangedWhenLoadSucceeds() throws InterruptedException
     );
   }
 
+  @Test
+  public void testBatchSize()
+  {
+    Assert.assertEquals(10, httpLoadQueuePeon.calculateBatchSize(SegmentLoadingMode.NORMAL));
+
+    // Without a batch size runtime parameter
+    httpLoadQueuePeon = new HttpLoadQueuePeon(
+        "http://dummy:4000",
+        MAPPER,
+        httpClient,
+        new HttpLoadQueuePeonConfig(null, null, null),
+        () -> SegmentLoadingMode.NORMAL,
+        new WrappingScheduledExecutorService(
+            "HttpLoadQueuePeonTest-%s",
+            httpClient.processingExecutor,
+            true
+        ),
+        httpClient.callbackExecutor
+    )
+    {
+      @Override
+      SegmentLoadingCapabilities fetchSegmentLoadingCapabilities()
+      {
+        return new SegmentLoadingCapabilities(1, 3);
+      }
+    };
+
+    Assert.assertEquals(1, httpLoadQueuePeon.calculateBatchSize(SegmentLoadingMode.NORMAL));
+    Assert.assertEquals(3, httpLoadQueuePeon.calculateBatchSize(SegmentLoadingMode.TURBO));
+  }
+
   private LoadPeonCallback markSegmentProcessed(DataSegment segment)
   {
     return success -> httpClient.processedSegments.add(segment);
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/simulate/CoordinatorSimulationBuilder.java b/server/src/test/java/org/apache/druid/server/coordinator/simulate/CoordinatorSimulationBuilder.java
index ddc360aa0124..938b6b09b1a0 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/simulate/CoordinatorSimulationBuilder.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/simulate/CoordinatorSimulationBuilder.java
@@ -454,19 +454,22 @@ private Environment(
           createBalancerStrategy(balancerStrategy),
           new HttpLoadQueuePeonConfig(null, null, null)
       );
+
+      JacksonConfigManager jacksonConfigManager = mockConfigManager();
+      setDynamicConfig(dynamicConfig);
+
       this.loadQueueTaskMaster = new LoadQueueTaskMaster(
           OBJECT_MAPPER,
           executorFactory.create(1, ExecutorFactory.LOAD_QUEUE_EXECUTOR),
           executorFactory.create(1, ExecutorFactory.LOAD_CALLBACK_EXECUTOR),
           coordinatorConfig.getHttpLoadQueuePeonConfig(),
-          httpClient
+          httpClient,
+          () -> dynamicConfig
       );
+
       this.loadQueueManager =
           new SegmentLoadQueueManager(coordinatorInventoryView, loadQueueTaskMaster);
 
-      JacksonConfigManager jacksonConfigManager = mockConfigManager();
-      setDynamicConfig(dynamicConfig);
-
       this.lookupCoordinatorManager = EasyMock.createNiceMock(LookupCoordinatorManager.class);
       mocks.add(jacksonConfigManager);
       mocks.add(lookupCoordinatorManager);
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/simulate/TestSegmentLoadingHttpClient.java b/server/src/test/java/org/apache/druid/server/coordinator/simulate/TestSegmentLoadingHttpClient.java
index 5caa90d8dfdb..877265d85b4e 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/simulate/TestSegmentLoadingHttpClient.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/simulate/TestSegmentLoadingHttpClient.java
@@ -24,6 +24,7 @@
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListeningScheduledExecutorService;
 import com.google.common.util.concurrent.MoreExecutors;
+import com.google.common.util.concurrent.SettableFuture;
 import org.apache.druid.java.util.http.client.HttpClient;
 import org.apache.druid.java.util.http.client.Request;
 import org.apache.druid.java.util.http.client.response.HttpResponseHandler;
@@ -32,6 +33,7 @@
 import org.apache.druid.server.coordination.DataSegmentChangeRequest;
 import org.apache.druid.server.coordination.DataSegmentChangeResponse;
 import org.apache.druid.server.coordination.SegmentChangeStatus;
+import org.apache.druid.server.http.SegmentLoadingCapabilities;
 import org.jboss.netty.buffer.ChannelBuffers;
 import org.jboss.netty.handler.codec.http.DefaultHttpResponse;
 import org.jboss.netty.handler.codec.http.HttpResponse;
@@ -79,12 +81,16 @@ public <Intermediate, Final> ListenableFuture<Final> go(
   }
 
   @Override
+  @SuppressWarnings("unchecked")
   public <Intermediate, Final> ListenableFuture<Final> go(
       Request request,
       HttpResponseHandler<Intermediate, Final> handler,
       Duration readTimeout
   )
   {
+    if (request.getUrl().toString().contains("/loadCapabilities")) {
+      return getCapabilities(handler);
+    }
     return executorService.submit(() -> processRequest(request, handler));
   }
 
@@ -143,6 +149,27 @@ private List<DataSegmentChangeResponse> processRequest(
         .collect(Collectors.toList());
   }
 
+  private <Intermediate, Final> ListenableFuture<Final> getCapabilities(HttpResponseHandler<Intermediate, Final> handler)
+  {
+    try {
+      // Set response content and status
+      final HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
+      response.setContent(ChannelBuffers.EMPTY_BUFFER);
+      handler.handleResponse(response, NOOP_TRAFFIC_COP);
+
+      // Serialize
+      SettableFuture future = SettableFuture.create();
+      try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
+        objectMapper.writeValue(baos, new SegmentLoadingCapabilities(1, 1));
+        future.set(new ByteArrayInputStream(baos.toByteArray()));
+      }
+      return future;
+    }
+    catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+  }
+
   /**
    * Processes each DataSegmentChangeRequest using the handler.
    */
diff --git a/server/src/test/java/org/apache/druid/server/http/CoordinatorDynamicConfigTest.java b/server/src/test/java/org/apache/druid/server/http/CoordinatorDynamicConfigTest.java
index eb7fb1992873..1be987ddc278 100644
--- a/server/src/test/java/org/apache/druid/server/http/CoordinatorDynamicConfigTest.java
+++ b/server/src/test/java/org/apache/druid/server/http/CoordinatorDynamicConfigTest.java
@@ -51,7 +51,8 @@ public void testSerde() throws Exception
                      + "  \"maxSegmentsInNodeLoadingQueue\": 1,\n"
                      + "  \"decommissioningNodes\": [\"host1\", \"host2\"],\n"
                      + "  \"pauseCoordination\": false,\n"
-                     + "  \"replicateAfterLoadTimeout\": false\n"
+                     + "  \"replicateAfterLoadTimeout\": false,\n"
+                     + "  \"turboLoadingNodes\":[\"host1\", \"host3\"]\n"
                      + "}\n";
 
     CoordinatorDynamicConfig actual = mapper.readValue(
@@ -65,6 +66,7 @@ public void testSerde() throws Exception
     );
     ImmutableSet<String> decommissioning = ImmutableSet.of("host1", "host2");
     ImmutableSet<String> whitelist = ImmutableSet.of("test1", "test2");
+    ImmutableSet<String> turboLoadingNodes = ImmutableSet.of("host1", "host3");
     assertConfig(
         actual,
         1,
@@ -78,7 +80,8 @@ public void testSerde() throws Exception
         1,
         decommissioning,
         false,
-        false
+        false,
+        turboLoadingNodes
     );
 
     actual = CoordinatorDynamicConfig.builder().withDecommissioningNodes(ImmutableSet.of("host1")).build(actual);
@@ -95,7 +98,8 @@ public void testSerde() throws Exception
         1,
         ImmutableSet.of("host1"),
         false,
-        false
+        false,
+        turboLoadingNodes
     );
 
     actual = CoordinatorDynamicConfig.builder().build(actual);
@@ -112,7 +116,8 @@ public void testSerde() throws Exception
         1,
         ImmutableSet.of("host1"),
         false,
-        false
+        false,
+        turboLoadingNodes
     );
 
     actual = CoordinatorDynamicConfig.builder().withPauseCoordination(true).build(actual);
@@ -129,7 +134,8 @@ public void testSerde() throws Exception
         1,
         ImmutableSet.of("host1"),
         true,
-        false
+        false,
+        turboLoadingNodes
     );
 
     actual = CoordinatorDynamicConfig.builder().withReplicateAfterLoadTimeout(true).build(actual);
@@ -146,7 +152,8 @@ public void testSerde() throws Exception
         1,
         ImmutableSet.of("host1"),
         true,
-        true
+        true,
+        turboLoadingNodes
     );
 
     actual = CoordinatorDynamicConfig.builder().build(actual);
@@ -163,7 +170,8 @@ public void testSerde() throws Exception
         1,
         ImmutableSet.of("host1"),
         true,
-        true
+        true,
+        turboLoadingNodes
     );
 
     actual = CoordinatorDynamicConfig.builder().withKillTaskSlotRatio(0.1).build(actual);
@@ -180,7 +188,8 @@ public void testSerde() throws Exception
         1,
         ImmutableSet.of("host1"),
         true,
-        true
+        true,
+        turboLoadingNodes
     );
 
     actual = CoordinatorDynamicConfig.builder().withMaxKillTaskSlots(5).build(actual);
@@ -197,7 +206,8 @@ public void testSerde() throws Exception
         1,
         ImmutableSet.of("host1"),
         true,
-        true
+        true,
+        turboLoadingNodes
     );
   }
 
@@ -233,7 +243,8 @@ public void testConstructorWithNullsShouldKillUnusedSegmentsInAllDataSources()
         true,
         false,
         false,
-        null
+        null,
+        ImmutableSet.of("host1")
     );
     Assert.assertTrue(config.getSpecificDataSourcesToKillUnusedSegmentsIn().isEmpty());
   }
@@ -257,7 +268,8 @@ public void testConstructorWithSpecificDataSourcesToKillShouldNotKillUnusedSegme
         true,
         false,
         false,
-        null
+        null,
+        ImmutableSet.of("host1")
     );
     Assert.assertEquals(ImmutableSet.of("test1"), config.getSpecificDataSourcesToKillUnusedSegmentsIn());
   }
@@ -272,7 +284,8 @@ public void testDecommissioningParametersBackwardCompatibility() throws Exceptio
                      + "  \"replicationThrottleLimit\": 1,\n"
                      + "  \"balancerComputeThreads\": 2, \n"
                      + "  \"killDataSourceWhitelist\": [\"test1\",\"test2\"],\n"
-                     + "  \"maxSegmentsInNodeLoadingQueue\": 1\n"
+                     + "  \"maxSegmentsInNodeLoadingQueue\": 1,\n"
+                     + "  \"turboLoadingNodes\": [\"host3\",\"host4\"]\n"
                      + "}\n";
 
     CoordinatorDynamicConfig actual = mapper.readValue(
@@ -286,6 +299,7 @@ public void testDecommissioningParametersBackwardCompatibility() throws Exceptio
     );
     ImmutableSet<String> decommissioning = ImmutableSet.of();
     ImmutableSet<String> whitelist = ImmutableSet.of("test1", "test2");
+    ImmutableSet<String> turboLoading = ImmutableSet.of("host3", "host4");
     assertConfig(
         actual,
         1,
@@ -299,7 +313,8 @@ public void testDecommissioningParametersBackwardCompatibility() throws Exceptio
         1,
         decommissioning,
         false,
-        false
+        false,
+        turboLoading
     );
 
     actual = CoordinatorDynamicConfig.builder().withDecommissioningNodes(ImmutableSet.of("host1")).build(actual);
@@ -316,7 +331,8 @@ public void testDecommissioningParametersBackwardCompatibility() throws Exceptio
         1,
         ImmutableSet.of("host1"),
         false,
-        false
+        false,
+        turboLoading
     );
 
     actual = CoordinatorDynamicConfig.builder().build(actual);
@@ -333,7 +349,8 @@ public void testDecommissioningParametersBackwardCompatibility() throws Exceptio
         1,
         ImmutableSet.of("host1"),
         false,
-        false
+        false,
+        turboLoading
     );
   }
 
@@ -372,7 +389,8 @@ public void testSerdeWithStringInKillDataSourceWhitelist() throws Exception
         1,
         ImmutableSet.of(),
         false,
-        false
+        false,
+        ImmutableSet.of()
     );
   }
 
@@ -411,7 +429,8 @@ public void testHandleMissingPercentOfSegmentsToConsiderPerMove() throws Excepti
         1,
         decommissioning,
         false,
-        false
+        false,
+        ImmutableSet.of()
     );
   }
 
@@ -446,7 +465,8 @@ public void testDeserializeWithoutMaxSegmentsInNodeLoadingQueue() throws Excepti
         EXPECTED_DEFAULT_MAX_SEGMENTS_IN_NODE_LOADING_QUEUE,
         ImmutableSet.of(),
         false,
-        false
+        false,
+        ImmutableSet.of()
     );
   }
 
@@ -468,7 +488,8 @@ public void testBuilderDefaults()
         EXPECTED_DEFAULT_MAX_SEGMENTS_IN_NODE_LOADING_QUEUE,
         emptyList,
         false,
-        false
+        false,
+        ImmutableSet.of()
     );
   }
 
@@ -493,7 +514,8 @@ public void testBuilderWithDefaultSpecificDataSourcesToKillUnusedSegmentsInSpeci
         EXPECTED_DEFAULT_MAX_SEGMENTS_IN_NODE_LOADING_QUEUE,
         ImmutableSet.of(),
         false,
-        false
+        false,
+        ImmutableSet.of()
     );
   }
 
@@ -511,6 +533,18 @@ public void testUpdate()
     );
   }
 
+  @Test
+  public void testTurboLoadingNodes()
+  {
+    CoordinatorDynamicConfig config = CoordinatorDynamicConfig
+        .builder()
+        .withTurboLoadingNodes(ImmutableSet.of("localhost:8083"))
+        .build();
+
+    Assert.assertEquals(SegmentLoadingMode.NORMAL, config.getLoadingModeForServer("localhost:8082"));
+    Assert.assertEquals(SegmentLoadingMode.TURBO, config.getLoadingModeForServer("localhost:8083"));
+  }
+
   @Test
   public void testEqualsAndHashCode()
   {
@@ -533,7 +567,8 @@ private void assertConfig(
       int expectedMaxSegmentsInNodeLoadingQueue,
       Set<String> decommissioningNodes,
       boolean pauseCoordination,
-      boolean replicateAfterLoadTimeout
+      boolean replicateAfterLoadTimeout,
+      Set<String> turboLoadingNodes
   )
   {
     Assert.assertEquals(
@@ -554,6 +589,7 @@ private void assertConfig(
     Assert.assertEquals(decommissioningNodes, config.getDecommissioningNodes());
     Assert.assertEquals(pauseCoordination, config.getPauseCoordination());
     Assert.assertEquals(replicateAfterLoadTimeout, config.getReplicateAfterLoadTimeout());
+    Assert.assertEquals(turboLoadingNodes, config.getTurboLoadingNodes());
   }
 
   private static int getDefaultNumBalancerThreads()
diff --git a/server/src/test/java/org/apache/druid/server/http/SegmentLoadingCapabilitiesTest.java b/server/src/test/java/org/apache/druid/server/http/SegmentLoadingCapabilitiesTest.java
new file mode 100644
index 000000000000..0819439a0aa9
--- /dev/null
+++ b/server/src/test/java/org/apache/druid/server/http/SegmentLoadingCapabilitiesTest.java
@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.server.http;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SegmentLoadingCapabilitiesTest
+{
+  private final ObjectMapper jsonMapper = new DefaultObjectMapper();
+
+  @Test
+  public void testSerde() throws Exception
+  {
+    SegmentLoadingCapabilities capabilities = new SegmentLoadingCapabilities(1, 4);
+
+    SegmentLoadingCapabilities reread = jsonMapper.readValue(jsonMapper.writeValueAsString(capabilities), SegmentLoadingCapabilities.class);
+
+    Assert.assertEquals(capabilities.getNumLoadingThreads(), reread.getNumLoadingThreads());
+    Assert.assertEquals(capabilities.getNumTurboLoadingThreads(), reread.getNumTurboLoadingThreads());
+  }
+
+  @Test
+  public void testSerdeFromJson() throws JsonProcessingException
+  {
+    String json = "{\"numLoadingThreads\":3,\"numTurboLoadingThreads\":5}";
+    SegmentLoadingCapabilities reread = jsonMapper.readValue(json, SegmentLoadingCapabilities.class);
+
+    Assert.assertEquals(3, reread.getNumLoadingThreads());
+    Assert.assertEquals(5, reread.getNumTurboLoadingThreads());
+  }
+}
diff --git a/services/src/main/java/org/apache/druid/cli/CliCoordinator.java b/services/src/main/java/org/apache/druid/cli/CliCoordinator.java
index b1fc5f634047..1f61d9716eba 100644
--- a/services/src/main/java/org/apache/druid/cli/CliCoordinator.java
+++ b/services/src/main/java/org/apache/druid/cli/CliCoordinator.java
@@ -306,7 +306,8 @@ public LoadQueueTaskMaster getLoadQueueTaskMaster(
               ScheduledExecutorFactory factory,
               DruidCoordinatorConfig config,
               @EscalatedGlobal HttpClient httpClient,
-              Lifecycle lifecycle
+              Lifecycle lifecycle,
+              CoordinatorConfigManager coordinatorConfigManager
           )
           {
             final ExecutorService callBackExec = Execs.singleThreaded("LoadQueuePeon-callbackexec--%d");
@@ -316,7 +317,8 @@ public LoadQueueTaskMaster getLoadQueueTaskMaster(
                 factory.create(1, "Master-PeonExec--%d"),
                 callBackExec,
                 config.getHttpLoadQueuePeonConfig(),
-                httpClient
+                httpClient,
+                coordinatorConfigManager::getCurrentDynamicConfig
             );
           }
         }

From 74573c9a4c18073921b321cfc64cded665c84937 Mon Sep 17 00:00:00 2001
From: Maytas Monsereenusorn <maytasm@apache.org>
Date: Tue, 25 Mar 2025 00:29:45 -0700
Subject: [PATCH 51/99] Fix resource leak for GroupBy query merge buffer when
 query matched result cache (#17823)

* Fix resource leak for GroupBy query merge buffer when match result cache

* Fix resource leak for GroupBy query merge buffer when match result cache

* Add test

* Add test

* Add comment

* Add test
---
 .../query/ResultLevelCachingQueryRunner.java  |  2 +
 .../ResultLevelCachingQueryRunnerTest.java    | 78 ++++++++++++++++++-
 2 files changed, 79 insertions(+), 1 deletion(-)

diff --git a/server/src/main/java/org/apache/druid/query/ResultLevelCachingQueryRunner.java b/server/src/main/java/org/apache/druid/query/ResultLevelCachingQueryRunner.java
index 8cc6348a7c8a..7e32e098a13e 100644
--- a/server/src/main/java/org/apache/druid/query/ResultLevelCachingQueryRunner.java
+++ b/server/src/main/java/org/apache/druid/query/ResultLevelCachingQueryRunner.java
@@ -106,6 +106,8 @@ public Sequence<T> run(QueryPlus queryPlus, ResponseContext responseContext)
 
       if (useResultCache && newResultSetId != null && newResultSetId.equals(existingResultSetId)) {
         log.debug("Return cached result set as there is no change in identifiers for query %s ", query.getId());
+        // Call accumulate on the sequence to ensure that all Wrapper/Closer/Baggage/etc. get called
+        resultFromClient.accumulate(null, (accumulated, in) -> accumulated);
         return deserializeResults(cachedResultSet, strategy, existingResultSetId);
       } else {
         @Nullable
diff --git a/server/src/test/java/org/apache/druid/query/ResultLevelCachingQueryRunnerTest.java b/server/src/test/java/org/apache/druid/query/ResultLevelCachingQueryRunnerTest.java
index 3cb4ae528e67..a0c14239e494 100644
--- a/server/src/test/java/org/apache/druid/query/ResultLevelCachingQueryRunnerTest.java
+++ b/server/src/test/java/org/apache/druid/query/ResultLevelCachingQueryRunnerTest.java
@@ -23,8 +23,13 @@
 import org.apache.druid.client.cache.Cache;
 import org.apache.druid.client.cache.CacheConfig;
 import org.apache.druid.client.cache.MapCache;
+import org.apache.druid.collections.BlockingPool;
+import org.apache.druid.collections.DefaultBlockingPool;
+import org.apache.druid.collections.ReferenceCountingResourceHolder;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.guava.Sequence;
+import org.apache.druid.java.util.common.guava.Sequences;
+import org.apache.druid.java.util.common.io.Closer;
 import org.apache.druid.query.timeseries.TimeseriesResultValue;
 import org.apache.druid.timeline.DataSegment;
 import org.joda.time.Interval;
@@ -32,10 +37,16 @@
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Mockito;
+import org.mockito.stubbing.Answer;
 
 import java.io.IOException;
+import java.nio.ByteBuffer;
 import java.util.List;
 
+import static org.junit.Assert.fail;
+
 public class ResultLevelCachingQueryRunnerTest extends QueryRunnerBasedOnClusteredClientTestBase
 {
   private Cache cache;
@@ -252,7 +263,7 @@ public void testPopulateCacheWhenQueryThrowExceptionShouldNotCache()
     );
     try {
       sequence.toList();
-      Assert.fail("Expected to throw an exception");
+      fail("Expected to throw an exception");
     }
     catch (RuntimeException e) {
       Assert.assertEquals("Exception for testing", e.getMessage());
@@ -264,6 +275,71 @@ public void testPopulateCacheWhenQueryThrowExceptionShouldNotCache()
     }
   }
 
+  @Test
+  public void testUseCacheAndReleaseResourceFromClient()
+  {
+    final BlockingPool<ByteBuffer> mergePool = new DefaultBlockingPool<>(() -> ByteBuffer.allocate(1), 1);
+    prepareCluster(10);
+    final Query<Result<TimeseriesResultValue>> query = timeseriesQuery(BASE_SCHEMA_INFO.getDataInterval());
+    CacheConfig cacheConfig = newCacheConfig(true, true, DEFAULT_CACHE_ENTRY_MAX_SIZE);
+    final QueryRunner<Result<TimeseriesResultValue>> baseRunner = cachingClusteredClient.getQueryRunnerForIntervals(query, query.getIntervals());
+    RetryQueryRunner<Result<TimeseriesResultValue>> spyRunner = Mockito.spy(new RetryQueryRunner<>(
+        baseRunner,
+        cachingClusteredClient::getQueryRunnerForSegments,
+        new RetryQueryRunnerConfig(),
+        objectMapper
+    ));
+    Mockito.doAnswer((Answer<Object>) invocation -> {
+      List<ReferenceCountingResourceHolder<ByteBuffer>> resoruce = mergePool.takeBatch(1, 1);
+      if (resoruce.isEmpty()) {
+        fail("Resource should not be empty");
+      }
+      Sequence<Result<TimeseriesResultValue>> realSequence = (Sequence<Result<TimeseriesResultValue>>) invocation.callRealMethod();
+      Closer closer = Closer.create();
+      closer.register(() -> resoruce.forEach(ReferenceCountingResourceHolder::close));
+      return Sequences.withBaggage(realSequence, closer);
+    }).when(spyRunner).run(ArgumentMatchers.any(), ArgumentMatchers.any());
+
+    final ResultLevelCachingQueryRunner<Result<TimeseriesResultValue>> queryRunner1 = new ResultLevelCachingQueryRunner<>(
+        spyRunner,
+        conglomerate.getToolChest(query),
+        query,
+        objectMapper,
+        cache,
+        cacheConfig
+    );
+
+    final Sequence<Result<TimeseriesResultValue>> sequence1 = queryRunner1.run(
+        QueryPlus.wrap(query),
+        responseContext()
+    );
+    final List<Result<TimeseriesResultValue>> results1 = sequence1.toList();
+    Assert.assertEquals(0, cache.getStats().getNumHits());
+    Assert.assertEquals(1, cache.getStats().getNumEntries());
+    Assert.assertEquals(1, cache.getStats().getNumMisses());
+
+
+    final Sequence<Result<TimeseriesResultValue>> sequence2 = queryRunner1.run(
+        QueryPlus.wrap(query),
+        responseContext()
+    );
+    final List<Result<TimeseriesResultValue>> results2 = sequence2.toList();
+    Assert.assertEquals(results1, results2);
+    Assert.assertEquals(1, cache.getStats().getNumHits());
+    Assert.assertEquals(1, cache.getStats().getNumEntries());
+    Assert.assertEquals(1, cache.getStats().getNumMisses());
+
+    final Sequence<Result<TimeseriesResultValue>> sequence3 = queryRunner1.run(
+        QueryPlus.wrap(query),
+        responseContext()
+    );
+    final List<Result<TimeseriesResultValue>> results3 = sequence3.toList();
+    Assert.assertEquals(results1, results3);
+    Assert.assertEquals(2, cache.getStats().getNumHits());
+    Assert.assertEquals(1, cache.getStats().getNumEntries());
+    Assert.assertEquals(1, cache.getStats().getNumMisses());
+  }
+
   private <T> ResultLevelCachingQueryRunner<T> createQueryRunner(
       CacheConfig cacheConfig,
       Query<T> query

From dc9120d23e30f8ad9d123d36bb57356516e8cda1 Mon Sep 17 00:00:00 2001
From: Kashif Faraz <kashif.faraz@gmail.com>
Date: Tue, 25 Mar 2025 13:53:17 +0530
Subject: [PATCH 52/99] Add metric and simulation test for turbo loading mode
 (#17830)

Changes
---------
- Add field `loadingMode` to `SegmentChangeStatus`
- Including loading mode in `DataSegmentChangeResponse`
- Include loading mode in the `description` of metrics emitted from `HttpLoadQueuePeon`
- Add simulation test to verify loading mode metrics
---
 .../BatchDataSegmentAnnouncer.java            | 19 +-----
 .../coordination/SegmentChangeStatus.java     | 67 +++++++++++++++++--
 .../coordination/SegmentLoadDropHandler.java  | 33 +++++----
 .../config/HttpLoadQueuePeonConfig.java       | 13 ++--
 .../loading/HttpLoadQueuePeon.java            | 42 +++++++-----
 .../server/http/SegmentListerResource.java    |  2 +-
 .../http/SegmentLoadingCapabilities.java      |  4 +-
 .../SegmentBootstrapperCacheTest.java         |  4 +-
 .../SegmentLoadDropHandlerTest.java           | 16 ++---
 .../config/HttpLoadQueuePeonConfigTest.java   | 21 +++---
 .../loading/HttpLoadQueuePeonTest.java        |  2 +-
 .../CoordinatorSimulationBaseTest.java        |  1 +
 .../simulate/SegmentLoadingTest.java          | 41 ++++++++++++
 .../TestSegmentLoadingHttpClient.java         | 21 +++++-
 14 files changed, 202 insertions(+), 84 deletions(-)

diff --git a/server/src/main/java/org/apache/druid/server/coordination/BatchDataSegmentAnnouncer.java b/server/src/main/java/org/apache/druid/server/coordination/BatchDataSegmentAnnouncer.java
index d95dee729af0..7fff124ac816 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/BatchDataSegmentAnnouncer.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/BatchDataSegmentAnnouncer.java
@@ -348,27 +348,12 @@ public ListenableFuture<ChangeRequestsSnapshot<DataSegmentChangeRequest>> getSeg
       synchronized (lock) {
         Iterable<DataSegmentChangeRequest> segments = Iterables.transform(
             segmentLookup.keySet(),
-            new Function<>()
-            {
-              @Nullable
-              @Override
-              public SegmentChangeRequestLoad apply(DataSegment input)
-              {
-                return new SegmentChangeRequestLoad(input);
-              }
-            }
+            SegmentChangeRequestLoad::new
         );
 
         Iterable<DataSegmentChangeRequest> sinkSchema = Iterables.transform(
             taskSinkSchema.values(),
-            new Function<>()
-            {
-              @Override
-              public SegmentSchemasChangeRequest apply(SegmentSchemas input)
-              {
-                return new SegmentSchemasChangeRequest(input);
-              }
-            }
+            SegmentSchemasChangeRequest::new
         );
         Iterable<DataSegmentChangeRequest> changeRequestIterables = Iterables.concat(segments, sinkSchema);
         SettableFuture<ChangeRequestsSnapshot<DataSegmentChangeRequest>> future = SettableFuture.create();
diff --git a/server/src/main/java/org/apache/druid/server/coordination/SegmentChangeStatus.java b/server/src/main/java/org/apache/druid/server/coordination/SegmentChangeStatus.java
index c19d1e7914a9..2e63c687060b 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/SegmentChangeStatus.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/SegmentChangeStatus.java
@@ -22,8 +22,10 @@
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.base.Preconditions;
+import org.apache.druid.server.http.SegmentLoadingMode;
 
 import javax.annotation.Nullable;
+import java.util.Objects;
 
 /**
  * Contains {@link State} of a {@link DataSegmentChangeRequest} and failure
@@ -39,23 +41,51 @@ public enum State
   private final State state;
   @Nullable
   private final String failureCause;
+  private final SegmentLoadingMode loadingMode;
 
-  public static final SegmentChangeStatus SUCCESS = new SegmentChangeStatus(State.SUCCESS, null);
-  public static final SegmentChangeStatus PENDING = new SegmentChangeStatus(State.PENDING, null);
+  private static final SegmentChangeStatus SUCCESS = new SegmentChangeStatus(State.SUCCESS, null, null);
+  private static final SegmentChangeStatus PENDING = new SegmentChangeStatus(State.PENDING, null, null);
+
+  public static SegmentChangeStatus success()
+  {
+    return SUCCESS;
+  }
+
+  public static SegmentChangeStatus success(SegmentLoadingMode loadingMode)
+  {
+    return new SegmentChangeStatus(State.SUCCESS, null, loadingMode);
+  }
+
+  public static SegmentChangeStatus pending()
+  {
+    return PENDING;
+  }
+
+  public static SegmentChangeStatus pending(SegmentLoadingMode loadingMode)
+  {
+    return new SegmentChangeStatus(State.PENDING, null, loadingMode);
+  }
+
+  public static SegmentChangeStatus failed(String cause, SegmentLoadingMode loadingMode)
+  {
+    return new SegmentChangeStatus(State.FAILED, cause, loadingMode);
+  }
 
   public static SegmentChangeStatus failed(String cause)
   {
-    return new SegmentChangeStatus(State.FAILED, cause);
+    return new SegmentChangeStatus(State.FAILED, cause, null);
   }
 
   @JsonCreator
   private SegmentChangeStatus(
       @JsonProperty("state") State state,
-      @JsonProperty("failureCause") @Nullable String failureCause
+      @JsonProperty("failureCause") @Nullable String failureCause,
+      @JsonProperty("loadingMode") @Nullable SegmentLoadingMode loadingMode
   )
   {
     this.state = Preconditions.checkNotNull(state, "state must be non-null");
     this.failureCause = failureCause;
+    this.loadingMode = loadingMode;
   }
 
   @JsonProperty
@@ -71,12 +101,41 @@ public String getFailureCause()
     return failureCause;
   }
 
+  @Nullable
+  @JsonProperty
+  public SegmentLoadingMode getLoadingMode()
+  {
+    return loadingMode;
+  }
+
+  @Override
+  public boolean equals(Object o)
+  {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    SegmentChangeStatus that = (SegmentChangeStatus) o;
+    return state == that.state
+           && Objects.equals(failureCause, that.failureCause)
+           && loadingMode == that.loadingMode;
+  }
+
+  @Override
+  public int hashCode()
+  {
+    return Objects.hash(state, failureCause, loadingMode);
+  }
+
   @Override
   public String toString()
   {
     return "SegmentChangeStatus{" +
            "state=" + state +
            ", failureCause='" + failureCause + '\'' +
+           ", loadingMode=" + loadingMode +
            '}';
   }
 }
diff --git a/server/src/main/java/org/apache/druid/server/coordination/SegmentLoadDropHandler.java b/server/src/main/java/org/apache/druid/server/coordination/SegmentLoadDropHandler.java
index 4d3e22c1a131..875fad0a8237 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/SegmentLoadDropHandler.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/SegmentLoadDropHandler.java
@@ -20,6 +20,7 @@
 package org.apache.druid.server.coordination;
 
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Throwables;
 import com.google.common.cache.Cache;
 import com.google.common.cache.CacheBuilder;
 import com.google.common.collect.ImmutableList;
@@ -57,7 +58,7 @@
  * Responsible for loading and dropping of segments by a process that can serve segments.
  */
 @ManageLifecycle
-public class SegmentLoadDropHandler implements DataSegmentChangeHandler
+public class SegmentLoadDropHandler
 {
   private static final EmittingLogger log = new EmittingLogger(SegmentLoadDropHandler.class);
 
@@ -125,6 +126,7 @@ public SegmentLoadDropHandler(
     this.normalLoadExec = normalLoadExec;
     this.turboLoadExec = turboLoadExec;
 
+    // Allow core threads to time out to save resources when not in turbo mode
     this.turboLoadExec.allowCoreThreadTimeOut(true);
 
     this.segmentsToDelete = new ConcurrentSkipListSet<>();
@@ -141,12 +143,15 @@ public Map<String, SegmentRowCountDistribution> getRowCountDistributionPerDataso
     return segmentManager.getRowCountDistribution();
   }
 
-  @Override
-  public void addSegment(DataSegment segment, @Nullable DataSegmentChangeCallback callback)
+  public void addSegment(
+      DataSegment segment,
+      @Nullable DataSegmentChangeCallback callback,
+      SegmentLoadingMode loadingMode
+  )
   {
     SegmentChangeStatus result = null;
     try {
-      log.info("Loading segment[%s]", segment.getId());
+      log.info("Loading segment[%s] in mode[%s]", segment.getId(), loadingMode);
       /*
          The lock below is used to prevent a race condition when the scheduled runnable in removeSegment() starts,
          and if (segmentsToDelete.remove(segment)) returns true, in which case historical will start deleting segment
@@ -179,13 +184,14 @@ each time when addSegment() is called, it has to wait for the lock in order to m
         throw new SegmentLoadingException(e, "Failed to announce segment[%s]", segment.getId());
       }
 
-      result = SegmentChangeStatus.SUCCESS;
+      result = SegmentChangeStatus.success(loadingMode);
     }
     catch (Throwable e) {
       log.makeAlert(e, "Failed to load segment")
          .addData("segment", segment)
          .emit();
-      result = SegmentChangeStatus.failed(e.toString());
+      Throwable rootCause = Throwables.getRootCause(e);
+      result = SegmentChangeStatus.failed(rootCause.toString(), loadingMode);
     }
     finally {
       updateRequestStatus(new SegmentChangeRequestLoad(segment), result);
@@ -195,7 +201,6 @@ each time when addSegment() is called, it has to wait for the lock in order to m
     }
   }
 
-  @Override
   public void removeSegment(DataSegment segment, @Nullable DataSegmentChangeCallback callback)
   {
     removeSegment(segment, callback, true);
@@ -242,7 +247,7 @@ void removeSegment(
         runnable.run();
       }
 
-      result = SegmentChangeStatus.SUCCESS;
+      result = SegmentChangeStatus.success();
     }
     catch (Exception e) {
       log.makeAlert(e, "Failed to remove segment")
@@ -322,11 +327,13 @@ public void addSegment(
                   @Nullable DataSegmentChangeCallback callback
               )
               {
-                requestStatuses.put(changeRequest, new AtomicReference<>(SegmentChangeStatus.PENDING));
-                getExecutorService(segmentLoadingMode).submit(
+                final SegmentChangeStatus pendingStatus = SegmentChangeStatus.pending(segmentLoadingMode);
+                requestStatuses.put(changeRequest, new AtomicReference<>(pendingStatus));
+                getLoadingExecutor(segmentLoadingMode).submit(
                     () -> SegmentLoadDropHandler.this.addSegment(
                         ((SegmentChangeRequestLoad) changeRequest).getSegment(),
-                        () -> resolveWaitingFutures()
+                        () -> resolveWaitingFutures(),
+                        segmentLoadingMode
                     )
                 );
               }
@@ -337,7 +344,7 @@ public void removeSegment(
                   @Nullable DataSegmentChangeCallback callback
               )
               {
-                requestStatuses.put(changeRequest, new AtomicReference<>(SegmentChangeStatus.PENDING));
+                requestStatuses.put(changeRequest, new AtomicReference<>(SegmentChangeStatus.pending()));
                 SegmentLoadDropHandler.this.removeSegment(
                     ((SegmentChangeRequestDrop) changeRequest).getSegment(),
                     () -> resolveWaitingFutures(),
@@ -428,7 +435,7 @@ public boolean cancel(boolean interruptIfRunning)
     }
   }
 
-  private ExecutorService getExecutorService(SegmentLoadingMode loadingMode)
+  private ExecutorService getLoadingExecutor(SegmentLoadingMode loadingMode)
   {
     return loadingMode == SegmentLoadingMode.TURBO ? turboLoadExec : normalLoadExec;
   }
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/config/HttpLoadQueuePeonConfig.java b/server/src/main/java/org/apache/druid/server/coordinator/config/HttpLoadQueuePeonConfig.java
index 42af2e948cf8..8c7cd7defb62 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/config/HttpLoadQueuePeonConfig.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/config/HttpLoadQueuePeonConfig.java
@@ -22,7 +22,7 @@
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import org.apache.druid.common.config.Configs;
-import org.apache.druid.java.util.common.RE;
+import org.apache.druid.error.InvalidInput;
 import org.joda.time.Duration;
 
 import javax.annotation.Nullable;
@@ -50,12 +50,13 @@ public HttpLoadQueuePeonConfig(
   {
     this.hostTimeout = Configs.valueOrDefault(hostTimeout, Duration.standardMinutes(5));
     this.repeatDelay = Configs.valueOrDefault(repeatDelay, Duration.standardMinutes(1));
-
-    if (batchSize != null && batchSize < 1) {
-      throw new RE("Batch size must be greater than 0.");
-    }
-
     this.batchSize = batchSize;
+
+    InvalidInput.conditionalException(
+        batchSize == null || batchSize >= 1,
+        "'druid.coordinator.loadqueuepeon.http.batchSize'[%s] must be greater than 0",
+        batchSize
+    );
   }
 
   @Nullable
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeon.java b/server/src/main/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeon.java
index 4f5ff04911ed..38eeb42413e7 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeon.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeon.java
@@ -210,7 +210,7 @@ private void doSegmentManagement()
         final SegmentHolder holder = queuedSegmentIterator.next();
         final DataSegment segment = holder.getSegment();
         if (holder.hasRequestTimedOut()) {
-          onRequestFailed(holder, "timed out");
+          onRequestFailed(holder, SegmentChangeStatus.failed("timed out"));
           queuedSegmentIterator.remove();
           if (holder.isLoad()) {
             segmentsToLoad.remove(segment);
@@ -407,9 +407,9 @@ private void updateSuccessOrFailureInHolder(SegmentHolder holder, SegmentChangeS
             queuedSegments.remove(holder);
             activeRequestSegments.remove(holder.getSegment());
             if (status.getState() == SegmentChangeStatus.State.FAILED) {
-              onRequestFailed(holder, status.getFailureCause());
+              onRequestFailed(holder, status);
             } else {
-              onRequestCompleted(holder, RequestStatus.SUCCESS);
+              onRequestCompleted(holder, RequestStatus.SUCCESS, status);
             }
           }
         }, null
@@ -452,7 +452,13 @@ public void stop()
       stopped = true;
 
       if (!queuedSegments.isEmpty()) {
-        queuedSegments.forEach(holder -> onRequestCompleted(holder, RequestStatus.CANCELLED));
+        queuedSegments.forEach(
+            holder -> onRequestCompleted(
+                holder,
+                RequestStatus.CANCELLED,
+                SegmentChangeStatus.failed("cancelled")
+            )
+        );
       }
 
       segmentsToDrop.clear();
@@ -487,13 +493,12 @@ public void loadSegment(DataSegment segment, SegmentAction action, LoadPeonCallb
 
       SegmentHolder holder = segmentsToLoad.get(segment);
       if (holder == null) {
-        log.trace("Server[%s] to load segment[%s] queued.", serverId, segment.getId());
         queuedSize.addAndGet(segment.getSize());
         holder = new SegmentHolder(segment, action, config.getLoadTimeout(), callback);
         segmentsToLoad.put(segment, holder);
         queuedSegments.add(holder);
         processingExecutor.execute(this::doSegmentManagement);
-        incrementStat(holder, RequestStatus.ASSIGNED);
+        incrementStat(holder, RequestStatus.ASSIGNED, null);
       } else {
         holder.addCallback(callback);
       }
@@ -522,7 +527,7 @@ public void dropSegment(DataSegment segment, LoadPeonCallback callback)
         segmentsToDrop.put(segment, holder);
         queuedSegments.add(holder);
         processingExecutor.execute(this::doSegmentManagement);
-        incrementStat(holder, RequestStatus.ASSIGNED);
+        incrementStat(holder, RequestStatus.ASSIGNED, null);
       } else {
         holder.addCallback(callback);
       }
@@ -593,16 +598,16 @@ public Set<DataSegment> getSegmentsMarkedToDrop()
     return Collections.unmodifiableSet(segmentsMarkedToDrop);
   }
 
-  private void onRequestFailed(SegmentHolder holder, String failureCause)
+  private void onRequestFailed(SegmentHolder holder, SegmentChangeStatus status)
   {
     log.error(
         "Server[%s] failed segment[%s] request[%s] with cause [%s].",
-        serverId, holder.getSegment().getId(), holder.getAction(), failureCause
+        serverId, holder.getSegment().getId(), holder.getAction(), status.getFailureCause()
     );
-    onRequestCompleted(holder, RequestStatus.FAILED);
+    onRequestCompleted(holder, RequestStatus.FAILED, status);
   }
 
-  private void onRequestCompleted(SegmentHolder holder, RequestStatus status)
+  private void onRequestCompleted(SegmentHolder holder, RequestStatus status, SegmentChangeStatus changeStatus)
   {
     final SegmentAction action = holder.getAction();
     log.trace(
@@ -613,14 +618,19 @@ private void onRequestCompleted(SegmentHolder holder, RequestStatus status)
     if (holder.isLoad()) {
       queuedSize.addAndGet(-holder.getSegment().getSize());
     }
-    incrementStat(holder, status);
+    incrementStat(holder, status, changeStatus);
     executeCallbacks(holder, status == RequestStatus.SUCCESS);
   }
 
-  private void incrementStat(SegmentHolder holder, RequestStatus status)
+  private void incrementStat(SegmentHolder holder, RequestStatus status, SegmentChangeStatus changeStatus)
   {
+    String description = holder.getAction().name();
+    if (changeStatus != null && changeStatus.getLoadingMode() != null) {
+      description += ": " + changeStatus.getLoadingMode().name();
+    }
+
     RowKey rowKey = RowKey.with(Dimension.DATASOURCE, holder.getSegment().getDataSource())
-                          .and(Dimension.DESCRIPTION, holder.getAction().name());
+                          .and(Dimension.DESCRIPTION, description);
     stats.get().add(status.datasourceStat, rowKey, 1);
   }
 
@@ -634,7 +644,7 @@ private void executeCallbacks(SegmentHolder holder, boolean success)
   }
 
   /**
-   * Tries to cancel a load/drop operation. An load/drop request can be cancelled
+   * Tries to cancel a load/drop operation. A load/drop request can be cancelled
    * only if it has not already been sent to the corresponding server.
    */
   @Override
@@ -654,7 +664,7 @@ public boolean cancelOperation(DataSegment segment)
       }
 
       queuedSegments.remove(holder);
-      onRequestCompleted(holder, RequestStatus.CANCELLED);
+      onRequestCompleted(holder, RequestStatus.CANCELLED, SegmentChangeStatus.failed("cancelled"));
       return true;
     }
   }
diff --git a/server/src/main/java/org/apache/druid/server/http/SegmentListerResource.java b/server/src/main/java/org/apache/druid/server/http/SegmentListerResource.java
index 48e037271995..25e823828222 100644
--- a/server/src/main/java/org/apache/druid/server/http/SegmentListerResource.java
+++ b/server/src/main/java/org/apache/druid/server/http/SegmentListerResource.java
@@ -62,7 +62,7 @@
 /**
  * Endpoints exposed here are to be used only for druid internal management of segments by Coordinators, Brokers etc.
  */
-@Path("/druid-internal/v1/segments/")
+@Path("/druid-internal/v1/segments")
 @ResourceFilters(StateResourceFilter.class)
 public class SegmentListerResource
 {
diff --git a/server/src/main/java/org/apache/druid/server/http/SegmentLoadingCapabilities.java b/server/src/main/java/org/apache/druid/server/http/SegmentLoadingCapabilities.java
index 9dba8af5e6bb..d74101482fab 100644
--- a/server/src/main/java/org/apache/druid/server/http/SegmentLoadingCapabilities.java
+++ b/server/src/main/java/org/apache/druid/server/http/SegmentLoadingCapabilities.java
@@ -41,13 +41,13 @@ public SegmentLoadingCapabilities(
     this.numTurboLoadingThreads = numTurboLoadingThreads;
   }
 
-  @JsonProperty("numLoadingThreads")
+  @JsonProperty
   public int getNumLoadingThreads()
   {
     return numLoadingThreads;
   }
 
-  @JsonProperty("numTurboLoadingThreads")
+  @JsonProperty
   public int getNumTurboLoadingThreads()
   {
     return numTurboLoadingThreads;
diff --git a/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperCacheTest.java b/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperCacheTest.java
index 187725317a21..17e862a50a9c 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperCacheTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperCacheTest.java
@@ -219,12 +219,12 @@ public void testLoadLocalCache() throws IOException, SegmentLoadingException
 
     // Make sure adding segments beyond allowed size fails
     DataSegment newSegment = TestSegmentUtils.makeSegment("test", "new-segment", SEGMENT_SIZE);
-    loadDropHandler.addSegment(newSegment, null);
+    loadDropHandler.addSegment(newSegment, null, null);
     Assert.assertFalse(segmentAnnouncer.getObservedSegments().contains(newSegment));
 
     // Clearing some segment should allow for new segments
     loadDropHandler.removeSegment(expectedSegments.get(0), null, false);
-    loadDropHandler.addSegment(newSegment, null);
+    loadDropHandler.addSegment(newSegment, null, null);
     Assert.assertTrue(segmentAnnouncer.getObservedSegments().contains(newSegment));
 
     bootstrapper.stop();
diff --git a/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java b/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
index 7a8822a60d87..99a2a1f7ad46 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
@@ -144,7 +144,7 @@ public void testSegmentLoading1()
 
     Assert.assertFalse(segmentAnnouncer.getObservedSegments().contains(segment));
 
-    handler.addSegment(segment, DataSegmentChangeCallback.NOOP);
+    handler.addSegment(segment, DataSegmentChangeCallback.NOOP, null);
 
     // Make sure the scheduled runnable that "deletes" segment files has been executed.
     // Because another addSegment() call is executed, which removes the segment from segmentsToDelete field in
@@ -186,7 +186,7 @@ public void testSegmentLoading2()
 
     final DataSegment segment = makeSegment("test", "1", Intervals.of("P1d/2011-04-01"));
 
-    handler.addSegment(segment, DataSegmentChangeCallback.NOOP);
+    handler.addSegment(segment, DataSegmentChangeCallback.NOOP, null);
 
     Assert.assertTrue(segmentAnnouncer.getObservedSegments().contains(segment));
 
@@ -194,7 +194,7 @@ public void testSegmentLoading2()
 
     Assert.assertFalse(segmentAnnouncer.getObservedSegments().contains(segment));
 
-    handler.addSegment(segment, DataSegmentChangeCallback.NOOP);
+    handler.addSegment(segment, DataSegmentChangeCallback.NOOP, null);
 
     // Make sure the scheduled runnable that "deletes" segment files has been executed.
     // Because another addSegment() call is executed, which removes the segment from segmentsToDelete field in
@@ -232,11 +232,11 @@ public void testProcessBatch() throws Exception
         new SegmentChangeRequestDrop(segment2)
     );
 
-    ListenableFuture<List<DataSegmentChangeResponse>> future = handler.processBatch(batch, SegmentLoadingMode.NORMAL);
+    ListenableFuture<List<DataSegmentChangeResponse>> future = handler.processBatch(batch, SegmentLoadingMode.TURBO);
 
     Map<DataSegmentChangeRequest, SegmentChangeStatus> expectedStatusMap = new HashMap<>();
-    expectedStatusMap.put(batch.get(0), SegmentChangeStatus.PENDING);
-    expectedStatusMap.put(batch.get(1), SegmentChangeStatus.SUCCESS);
+    expectedStatusMap.put(batch.get(0), SegmentChangeStatus.pending(SegmentLoadingMode.TURBO));
+    expectedStatusMap.put(batch.get(1), SegmentChangeStatus.success());
     List<DataSegmentChangeResponse> result = future.get();
     for (DataSegmentChangeResponse requestAndStatus : result) {
       Assert.assertEquals(expectedStatusMap.get(requestAndStatus.getRequest()), requestAndStatus.getStatus());
@@ -247,7 +247,7 @@ public void testProcessBatch() throws Exception
     }
 
     result = handler.processBatch(ImmutableList.of(new SegmentChangeRequestLoad(segment1)), SegmentLoadingMode.TURBO).get();
-    Assert.assertEquals(SegmentChangeStatus.SUCCESS, result.get(0).getStatus());
+    Assert.assertEquals(SegmentChangeStatus.success(SegmentLoadingMode.TURBO), result.get(0).getStatus());
 
     Assert.assertEquals(ImmutableList.of(segment1), segmentAnnouncer.getObservedSegments());
 
@@ -287,7 +287,7 @@ public void testProcessBatchDuplicateLoadRequestsWhenFirstRequestFailsSecondRequ
       runnable.run();
     }
     result = future.get();
-    Assert.assertEquals(State.SUCCESS, result.get(0).getStatus().getState());
+    Assert.assertEquals(SegmentChangeStatus.success(SegmentLoadingMode.NORMAL), result.get(0).getStatus());
     Assert.assertEquals(ImmutableList.of(segment1, segment1), segmentAnnouncer.getObservedSegments());
 
   }
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/config/HttpLoadQueuePeonConfigTest.java b/server/src/test/java/org/apache/druid/server/coordinator/config/HttpLoadQueuePeonConfigTest.java
index 4d9a2400215c..4f4528414b20 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/config/HttpLoadQueuePeonConfigTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/config/HttpLoadQueuePeonConfigTest.java
@@ -22,28 +22,27 @@
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.exc.ValueInstantiationException;
-import org.hamcrest.CoreMatchers;
+import com.google.common.base.Throwables;
+import org.apache.druid.error.DruidExceptionMatcher;
 import org.hamcrest.MatcherAssert;
 import org.junit.Assert;
 import org.junit.Test;
-import org.junit.internal.matchers.ThrowableMessageMatcher;
 
 public class HttpLoadQueuePeonConfigTest
 {
   @Test
   public void testValidateBatchSize() throws JsonProcessingException
   {
-    ObjectMapper jsonMapper = new ObjectMapper();
+    final ObjectMapper jsonMapper = new ObjectMapper();
 
     MatcherAssert.assertThat(
-        Assert.assertThrows(ValueInstantiationException.class, () ->
-            jsonMapper.readValue("{\"batchSize\":0}", HttpLoadQueuePeonConfig.class)
-        ),
-        CoreMatchers.allOf(
-            CoreMatchers.instanceOf(ValueInstantiationException.class),
-            ThrowableMessageMatcher.hasMessage(
-                CoreMatchers.containsString("Batch size must be greater than 0.")
+        Throwables.getRootCause(
+            Assert.assertThrows(ValueInstantiationException.class, () ->
+                jsonMapper.readValue("{\"batchSize\":0}", HttpLoadQueuePeonConfig.class)
             )
+        ),
+        DruidExceptionMatcher.invalidInput().expectMessageIs(
+            "'druid.coordinator.loadqueuepeon.http.batchSize'[0] must be greater than 0"
         )
     );
 
@@ -57,6 +56,6 @@ public void testValidateBatchSize() throws JsonProcessingException
         "{\"batchSize\":2}",
         HttpLoadQueuePeonConfig.class
     );
-    Assert.assertEquals(2, config.getBatchSize().intValue());
+    Assert.assertEquals(Integer.valueOf(2), config.getBatchSize());
   }
 }
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeonTest.java b/server/src/test/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeonTest.java
index e511ce77ee2c..fba98bff3aec 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeonTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/loading/HttpLoadQueuePeonTest.java
@@ -398,7 +398,7 @@ public <Intermediate, Final> ListenableFuture<Final> go(
         for (DataSegmentChangeRequest cr : changeRequests) {
           cr.go(this, null);
           statuses.add(
-              new DataSegmentChangeResponse(cr, SegmentChangeStatus.SUCCESS)
+              new DataSegmentChangeResponse(cr, SegmentChangeStatus.success())
           );
         }
         return (ListenableFuture<Final>) Futures.immediateFuture(
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/simulate/CoordinatorSimulationBaseTest.java b/server/src/test/java/org/apache/druid/server/coordinator/simulate/CoordinatorSimulationBaseTest.java
index 1fd3d54dc456..b9db5921ee36 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/simulate/CoordinatorSimulationBaseTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/simulate/CoordinatorSimulationBaseTest.java
@@ -217,6 +217,7 @@ static class Metric
     static final String DELETED_COUNT = "segment/deleted/count";
     static final String LOAD_QUEUE_COUNT = "segment/loadQueue/count";
     static final String DROP_QUEUE_COUNT = "segment/dropQueue/count";
+    static final String SUCCESS_ACTIONS = "segment/loadQueue/success";
     static final String CANCELLED_ACTIONS = "segment/loadQueue/cancelled";
 
     static final String OVERSHADOWED_COUNT = "segment/overshadowed/count";
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/simulate/SegmentLoadingTest.java b/server/src/test/java/org/apache/druid/server/coordinator/simulate/SegmentLoadingTest.java
index e2127f090d87..bfc28abc1cc8 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/simulate/SegmentLoadingTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/simulate/SegmentLoadingTest.java
@@ -28,6 +28,8 @@
 
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * Coordinator simulation test to verify behaviour of segment loading.
@@ -542,6 +544,45 @@ public void testSegmentsAreDroppedFromFullServersFirst()
     Assert.assertEquals(historicalT11.getCurrSize(), historicalT12.getCurrSize());
   }
 
+  @Test
+  public void testSegmentLoadingModes()
+  {
+    CoordinatorDynamicConfig config =
+        CoordinatorDynamicConfig.builder()
+                                .withTurboLoadingNodes(Set.of(historicalT11.getName()))
+                                .build();
+
+    final CoordinatorSimulation sim =
+        CoordinatorSimulation.builder()
+                             .withServers(historicalT11, historicalT12)
+                             .withDynamicConfig(config)
+                             .withRules(datasource, Load.on(Tier.T1, 1).forever())
+                             .withSegments(Segments.WIKI_10X1D)
+                             .build();
+
+    startSimulation(sim);
+
+    // Run 1: Assign and load all segments
+    runCoordinatorCycle();
+    loadQueuedSegments();
+    verifyValue(Metric.ASSIGNED_COUNT, 10L);
+    Assert.assertEquals(5, historicalT11.getTotalSegments());
+    Assert.assertEquals(5, historicalT12.getTotalSegments());
+
+    // Run 2: Emit success metrics
+    runCoordinatorCycle();
+    verifyValue(
+        Metric.SUCCESS_ACTIONS,
+        Map.of("server", historicalT11.getName(), "description", "LOAD: TURBO"),
+        5L
+    );
+    verifyValue(
+        Metric.SUCCESS_ACTIONS,
+        Map.of("server", historicalT12.getName(), "description", "LOAD: NORMAL"),
+        5L
+    );
+  }
+
   private int getNumLoadedSegments(DruidServer... servers)
   {
     int numLoaded = 0;
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/simulate/TestSegmentLoadingHttpClient.java b/server/src/test/java/org/apache/druid/server/coordinator/simulate/TestSegmentLoadingHttpClient.java
index 877265d85b4e..ae911c4d8ae1 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/simulate/TestSegmentLoadingHttpClient.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/simulate/TestSegmentLoadingHttpClient.java
@@ -34,6 +34,7 @@
 import org.apache.druid.server.coordination.DataSegmentChangeResponse;
 import org.apache.druid.server.coordination.SegmentChangeStatus;
 import org.apache.druid.server.http.SegmentLoadingCapabilities;
+import org.apache.druid.server.http.SegmentLoadingMode;
 import org.jboss.netty.buffer.ChannelBuffers;
 import org.jboss.netty.handler.codec.http.DefaultHttpResponse;
 import org.jboss.netty.handler.codec.http.HttpResponse;
@@ -81,7 +82,6 @@ public <Intermediate, Final> ListenableFuture<Final> go(
   }
 
   @Override
-  @SuppressWarnings("unchecked")
   public <Intermediate, Final> ListenableFuture<Final> go(
       Request request,
       HttpResponseHandler<Intermediate, Final> handler,
@@ -143,9 +143,11 @@ private List<DataSegmentChangeResponse> processRequest(
         new TypeReference<>() {}
     );
 
+    final SegmentLoadingMode loadingMode = getLoadingMode(request);
+
     return changeRequests
         .stream()
-        .map(changeRequest -> processRequest(changeRequest, changeHandler))
+        .map(changeRequest -> processRequest(changeRequest, loadingMode, changeHandler))
         .collect(Collectors.toList());
   }
 
@@ -175,13 +177,14 @@ private <Intermediate, Final> ListenableFuture<Final> getCapabilities(HttpRespon
    */
   private DataSegmentChangeResponse processRequest(
       DataSegmentChangeRequest request,
+      SegmentLoadingMode loadingMode,
       DataSegmentChangeHandler handler
   )
   {
     SegmentChangeStatus status;
     try {
       request.go(handler, NOOP_CALLBACK);
-      status = SegmentChangeStatus.SUCCESS;
+      status = SegmentChangeStatus.success(loadingMode);
     }
     catch (Exception e) {
       status = SegmentChangeStatus.failed(e.getMessage());
@@ -189,4 +192,16 @@ private DataSegmentChangeResponse processRequest(
 
     return new DataSegmentChangeResponse(request, status);
   }
+
+  private static SegmentLoadingMode getLoadingMode(Request request)
+  {
+    String url = request.getUrl().toString();
+    String[] splits = url.split("loadingMode=");
+
+    if (splits.length > 1) {
+      return SegmentLoadingMode.valueOf(splits[1]);
+    } else {
+      return SegmentLoadingMode.NORMAL;
+    }
+  }
 }

From 9b2cc567f76fa739d7728930b598c7da4b78dc92 Mon Sep 17 00:00:00 2001
From: Katya Macedo <38017980+ektravel@users.noreply.github.com>
Date: Tue, 25 Mar 2025 13:53:21 -0500
Subject: [PATCH 53/99] Update query example (#17811)

---
 docs/querying/multi-value-dimensions.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/querying/multi-value-dimensions.md b/docs/querying/multi-value-dimensions.md
index e41e8630ebb1..a77a7766f279 100644
--- a/docs/querying/multi-value-dimensions.md
+++ b/docs/querying/multi-value-dimensions.md
@@ -252,7 +252,7 @@ results in:
 ```sql
 SELECT label, tags
 FROM "mvd_example_rollup"
-WHERE tags = 't3'
+WHERE label in ('row1','row2')
 GROUP BY 1,2
 ```
 

From f22ae4222e1bcd5d14d1cd60ba1262c5b148d6ef Mon Sep 17 00:00:00 2001
From: Virushade <70288012+GWphua@users.noreply.github.com>
Date: Wed, 26 Mar 2025 14:35:53 +0800
Subject: [PATCH 54/99] String util upgrade for jdk9+ (#17795)

* Update StringUtils.replace() after fix in JDK9

* Upgrade optimized string replace algorithm

* Update methods by re-using declared StringUtils#replace method

* Replace hard-coded UTF-8 encodings with StandardCharsets
---
 .../druid/java/util/common/StringUtils.java   | 84 +++----------------
 1 file changed, 11 insertions(+), 73 deletions(-)

diff --git a/processing/src/main/java/org/apache/druid/java/util/common/StringUtils.java b/processing/src/main/java/org/apache/druid/java/util/common/StringUtils.java
index d8ef9956d9bf..4c3f334636fa 100644
--- a/processing/src/main/java/org/apache/druid/java/util/common/StringUtils.java
+++ b/processing/src/main/java/org/apache/druid/java/util/common/StringUtils.java
@@ -20,6 +20,7 @@
 package org.apache.druid.java.util.common;
 
 import com.google.common.base.Strings;
+import io.netty.util.SuppressForbidden;
 import org.apache.commons.io.IOUtils;
 
 import javax.annotation.Nonnull;
@@ -261,7 +262,7 @@ public static String fromUtf8(final ByteBuffer buffer)
   }
 
   /**
-   * If buffer is Decodes a UTF-8 string from the remaining bytes of a buffer.
+   * If buffer is not null, decodes a UTF-8 string from the remaining bytes of a buffer.
    * Advances the position of the buffer by {@link ByteBuffer#remaining()}.
    *
    * If the value is null, this method returns null. If the buffer will never be null, use {@link #fromUtf8(ByteBuffer)}
@@ -421,12 +422,7 @@ public static String urlEncode(@Nullable String s)
       return null;
     }
 
-    try {
-      return StringUtils.replace(URLEncoder.encode(s, "UTF-8"), "+", "%20");
-    }
-    catch (UnsupportedEncodingException e) {
-      throw new RuntimeException(e);
-    }
+    return StringUtils.replace(URLEncoder.encode(s, StandardCharsets.UTF_8), "+", "%20");
   }
 
   @Nullable
@@ -436,12 +432,7 @@ public static String urlDecode(String s)
       return null;
     }
 
-    try {
-      return URLDecoder.decode(s, "UTF-8");
-    }
-    catch (UnsupportedEncodingException e) {
-      throw new RuntimeException(e);
-    }
+    return URLDecoder.decode(s, StandardCharsets.UTF_8);
   }
 
   public static String maybeRemoveLeadingSlash(String s)
@@ -460,81 +451,28 @@ public static String maybeAppendTrailingSlash(String s)
   }
 
   /**
-   * Removes all occurrences of the given char from the given string. This method is an optimal version of
-   * {@link String#replace(CharSequence, CharSequence) s.replace("c", "")}.
+   * Removes all occurrences of the given char from the given string.
    */
   public static String removeChar(String s, char c)
   {
-    int pos = s.indexOf(c);
-    if (pos < 0) {
-      return s;
-    }
-    StringBuilder sb = new StringBuilder(s.length() - 1);
-    int prevPos = 0;
-    do {
-      sb.append(s, prevPos, pos);
-      prevPos = pos + 1;
-      pos = s.indexOf(c, pos + 1);
-    } while (pos > 0);
-    sb.append(s, prevPos, s.length());
-    return sb.toString();
+    return StringUtils.replace(s, String.valueOf(c), "");
   }
 
   /**
-   * Replaces all occurrences of the given char in the given string with the given replacement string. This method is an
-   * optimal version of {@link String#replace(CharSequence, CharSequence) s.replace("c", replacement)}.
+   * Replaces all occurrences of the given char in the given string with the given replacement string.
    */
   public static String replaceChar(String s, char c, String replacement)
   {
-    int pos = s.indexOf(c);
-    if (pos < 0) {
-      return s;
-    }
-    StringBuilder sb = new StringBuilder(s.length() - 1 + replacement.length());
-    int prevPos = 0;
-    do {
-      sb.append(s, prevPos, pos);
-      sb.append(replacement);
-      prevPos = pos + 1;
-      pos = s.indexOf(c, pos + 1);
-    } while (pos > 0);
-    sb.append(s, prevPos, s.length());
-    return sb.toString();
+    return StringUtils.replace(s, String.valueOf(c), replacement);
   }
 
   /**
-   * Replaces all occurrences of the given target substring in the given string with the given replacement string. This
-   * method is an optimal version of {@link String#replace(CharSequence, CharSequence) s.replace(target, replacement)}.
+   * Replaces all occurrences of the given target substring in the given string with the given replacement string.
    */
+  @SuppressForbidden(reason = "String#replace")
   public static String replace(String s, String target, String replacement)
   {
-    // String.replace() is suboptimal in JDK8, but is fixed in JDK9+. When the minimal JDK version supported by Druid is
-    // JDK9+, the implementation of this method should be replaced with simple delegation to String.replace(). However,
-    // the method should still be prohibited to use in all other places except this method body, because it's easy to
-    // suboptimally call String.replace("a", "b"), String.replace("a", ""), String.replace("a", "abc"), which have
-    // better alternatives String.replace('a', 'b'), removeChar() and replaceChar() respectively.
-    int pos = s.indexOf(target);
-    if (pos < 0) {
-      return s;
-    }
-    int sLength = s.length();
-    int targetLength = target.length();
-    // This is needed to work correctly with empty target string and mimic String.replace() behavior
-    int searchSkip = Math.max(targetLength, 1);
-    StringBuilder sb = new StringBuilder(sLength - targetLength + replacement.length());
-    int prevPos = 0;
-    do {
-      sb.append(s, prevPos, pos);
-      sb.append(replacement);
-      prevPos = pos + targetLength;
-      // Break from the loop if the target is empty
-      if (pos == sLength) {
-        break;
-      }
-      pos = s.indexOf(target, pos + searchSkip);
-    } while (pos > 0);
-    sb.append(s, prevPos, sLength);
-    return sb.toString();
+    return s.replace(target, replacement);
   }
 
   /**

From c4e579b81cfdf25c176583a992632d71d8c16273 Mon Sep 17 00:00:00 2001
From: Virushade <70288012+GWphua@users.noreply.github.com>
Date: Wed, 26 Mar 2025 14:35:58 +0800
Subject: [PATCH 55/99] Documentation Fix (#17826)

---
 docs/operations/metrics.md | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/docs/operations/metrics.md b/docs/operations/metrics.md
index 926740b5fb42..044d32960482 100644
--- a/docs/operations/metrics.md
+++ b/docs/operations/metrics.md
@@ -85,6 +85,13 @@ Most metric values reset each emission period, as specified in `druid.monitoring
 |`subquery/fallback/unknownReason/count`|Number of subqueries which cannot be materialized as frames due other reasons.|This metric is only available if the `SubqueryCountStatsMonitor` module is included.| |
 |`query/rowLimit/exceeded/count`|Number of queries whose inlined subquery results exceeded the given row limit|This metric is only available if the `SubqueryCountStatsMonitor` module is included.| |
 |`query/byteLimit/exceeded/count`|Number of queries whose inlined subquery results exceeded the given byte limit|This metric is only available if the `SubqueryCountStatsMonitor` module is included.| |
+|`mergeBuffer/pendingRequests`|Number of requests waiting to acquire a batch of buffers from the merge buffer pool.|This metric is only available if the `GroupByStatsMonitor` module is included.|Should be ideally 0, though a higher number isn't representative of a problem.|
+|`mergeBuffer/used`|Number of merge buffers used from the merge buffer pool.|This metric is only available if the `GroupByStatsMonitor` module is included.|Depends on the number of groupBy queries needing merge buffers.|
+|`mergeBuffer/queries`|Number of groupBy queries that acquired a batch of buffers from the merge buffer pool.|This metric is only available if the `GroupByStatsMonitor` module is included.|Depends on the number of groupBy queries needing merge buffers.|
+|`mergeBuffer/acquisitionTimeNs`|Total time in nanoseconds to acquire merge buffer for groupBy queries.|This metric is only available if the `GroupByStatsMonitor` module is included.|Varies|
+|`groupBy/spilledQueries`|Number of groupBy queries that have spilled onto the disk.|This metric is only available if the `GroupByStatsMonitor` module is included.|Varies|
+|`groupBy/spilledBytes`|Number of bytes spilled on the disk by the groupBy queries.|This metric is only available if the `GroupByStatsMonitor` module is included.|Varies|
+|`groupBy/mergeDictionarySize`|Size of on-heap merge dictionary in bytes.|This metric is only available if the `GroupByStatsMonitor` module is included.|Varies|
 
 ### Historical
 
@@ -102,6 +109,13 @@ Most metric values reset each emission period, as specified in `druid.monitoring
 |`query/failed/count`|Number of failed queries.|This metric is only available if the `QueryCountStatsMonitor` module is included.||
 |`query/interrupted/count`|Number of queries interrupted due to cancellation.|This metric is only available if the `QueryCountStatsMonitor` module is included.||
 |`query/timeout/count`|Number of timed out queries.|This metric is only available if the `QueryCountStatsMonitor` module is included.||
+|`mergeBuffer/pendingRequests`|Number of requests waiting to acquire a batch of buffers from the merge buffer pool.|This metric is only available if the `GroupByStatsMonitor` module is included.|Should be ideally 0, though a higher number isn't representative of a problem.|
+|`mergeBuffer/used`|Number of merge buffers used from the merge buffer pool.|This metric is only available if the `GroupByStatsMonitor` module is included.|Depends on the number of groupBy queries needing merge buffers.|
+|`mergeBuffer/queries`|Number of groupBy queries that acquired a batch of buffers from the merge buffer pool.|This metric is only available if the `GroupByStatsMonitor` module is included.|Depends on the number of groupBy queries needing merge buffers.|
+|`mergeBuffer/acquisitionTimeNs`|Total time in nanoseconds to acquire merge buffer for groupBy queries.|This metric is only available if the `GroupByStatsMonitor` module is included.|Varies|
+|`groupBy/spilledQueries`|Number of groupBy queries that have spilled onto the disk.|This metric is only available if the `GroupByStatsMonitor` module is included.|Varies|
+|`groupBy/spilledBytes`|Number of bytes spilled on the disk by the groupBy queries.|This metric is only available if the `GroupByStatsMonitor` module is included.|Varies|
+|`groupBy/mergeDictionarySize`|Size of on-heap merge dictionary in bytes.|This metric is only available if the `GroupByStatsMonitor` module is included.|Varies|
 
 ### Real-time
 
@@ -117,13 +131,6 @@ Most metric values reset each emission period, as specified in `druid.monitoring
 |`query/failed/count`|Number of failed queries.|This metric is only available if the `QueryCountStatsMonitor` module is included.||
 |`query/interrupted/count`|Number of queries interrupted due to cancellation.|This metric is only available if the `QueryCountStatsMonitor` module is included.||
 |`query/timeout/count`|Number of timed out queries.|This metric is only available if the `QueryCountStatsMonitor` module is included.||
-
-### GroupBy query metrics 
-
-These metrics are reported from broker, historical and real-time nodes 
-
-|Metric|Description|Normal value|
-|------|-----------|------------|
 |`mergeBuffer/pendingRequests`|Number of requests waiting to acquire a batch of buffers from the merge buffer pool.|This metric is only available if the `GroupByStatsMonitor` module is included.|Should be ideally 0, though a higher number isn't representative of a problem.|
 |`mergeBuffer/used`|Number of merge buffers used from the merge buffer pool.|This metric is only available if the `GroupByStatsMonitor` module is included.|Depends on the number of groupBy queries needing merge buffers.|
 |`mergeBuffer/queries`|Number of groupBy queries that acquired a batch of buffers from the merge buffer pool.|This metric is only available if the `GroupByStatsMonitor` module is included.|Depends on the number of groupBy queries needing merge buffers.|

From 5e03854d8688df81822963feb62b491486e910ac Mon Sep 17 00:00:00 2001
From: Zoltan Haindrich <kirk@rxd.hu>
Date: Wed, 26 Mar 2025 15:56:26 +0100
Subject: [PATCH 56/99] Enable to run quidem tests against multiple
 configurations; add conditionals; cleanup framework init (#17829)

* cleans up `SqlTestFramework` initialization to leave the `OverrideModule` empty - so that tests could more easily take over parts
* remove the `QueryComponentSupplier#createEngine`  factory method - instead uses a `Class<SqlEngine>` and use the `injector` to initialize it
* enables the usage of `!disabled <supplier> <message>` - to mark cases which are not yet supported with a specific configuration for some reason
* fixes that `datasets` was not respecting the `rollup` specification of the ingest
* enables to use `MultiComponentSupplier` backed tests - these will turn into matrix tests over multiple componentsuppliers - enabling running the same testcase in different scenarios
---
 .../druid/msq/quidem/MSQQuidemTest.java       |   4 +-
 .../AbstractMSQComponentSupplierDelegate.java |  11 +-
 .../AllDruidEnginesComponentSupplier.java     |  32 ++
 .../druid/msq/test/CalciteMSQTestsHelper.java |  26 --
 .../druid/msq/test/DartComponentSupplier.java |  10 +-
 .../org/apache/druid/concurrent/Threads.java  |  15 +-
 .../druid/initialization/DruidModule.java     |  33 ++
 .../apache/druid/concurrent/ThreadsTest.java  |  38 ++
 .../druid/initialization/DruidModuleTest.java |  98 ++++
 ...AsBrokerQueryComponentSupplierWrapper.java |  15 -
 .../java/org/apache/druid/quidem/QTest.java   |   2 +-
 .../dart_with_datasets.iq                     |  13 -
 .../testframework_all_engines_dataset.iq      |  17 +
 .../testframework_all_engines_disabled.iq     |  20 +
 .../{dart1.iq => testframework_dart.iq}       |   0
 .../{example.iq => testframework_example.iq}  |   0
 .../guice/ServiceInjectorBuilderTest.java     | 126 ++++++
 .../datasets/InputSourceBasedTestDataset.java |   3 +-
 .../schema/DruidCalciteSchemaModule.java      |  11 +-
 .../druid/sql/calcite/schema/DruidSchema.java |   3 +-
 .../calcite/schema/DruidSchemaManager.java    |  11 +-
 .../org/apache/druid/sql/http/SqlQuery.java   |   5 +
 .../druid/quidem/DruidAvaticaTestDriver.java  |  11 +-
 .../druid/quidem/DruidConnectionExtras.java   |  12 +
 .../quidem/DruidQuidemCommandHandler.java     |  81 +++-
 .../quidem/DruidQuidemConnectionFactory.java  |  53 ++-
 .../druid/quidem/DruidQuidemTestBase.java     | 194 +++++++-
 .../apache/druid/quidem/SqlQuidemTest.java    |   2 +-
 .../sql/calcite/BaseCalciteQueryTest.java     |   5 +
 .../sql/calcite/CalciteIngestionDmlTest.java  |   8 +-
 .../sql/calcite/CalciteScanSignatureTest.java |  19 +-
 .../sql/calcite/IngestionTestSqlEngine.java   |   4 +-
 .../sql/calcite/MultiComponentSupplier.java   | 173 ++++++++
 .../apache/druid/sql/calcite/QTestCase.java   |   3 +-
 .../sql/calcite/SqlTestFrameworkConfig.java   |  33 +-
 .../druid/sql/calcite/util/CalciteTests.java  |  15 +-
 .../calcite/util/DruidModuleCollection.java   |  25 +-
 .../sql/calcite/util/QueryFrameworkUtils.java |  11 +-
 .../sql/calcite/util/SqlTestFramework.java    | 418 ++++++++++--------
 .../sql/calcite/util/TestDataBuilder.java     |   6 +-
 .../customdataset.iq                          |   2 +-
 41 files changed, 1208 insertions(+), 360 deletions(-)
 create mode 100644 extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/AllDruidEnginesComponentSupplier.java
 create mode 100644 processing/src/test/java/org/apache/druid/concurrent/ThreadsTest.java
 create mode 100644 processing/src/test/java/org/apache/druid/initialization/DruidModuleTest.java
 delete mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/dart_with_datasets.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/testframework_all_engines_dataset.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/testframework_all_engines_disabled.iq
 rename quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/{dart1.iq => testframework_dart.iq} (100%)
 rename quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/{example.iq => testframework_example.iq} (100%)
 create mode 100644 server/src/test/java/org/apache/druid/guice/ServiceInjectorBuilderTest.java
 create mode 100644 sql/src/test/java/org/apache/druid/sql/calcite/MultiComponentSupplier.java

diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/quidem/MSQQuidemTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/quidem/MSQQuidemTest.java
index 30deed4b6263..5f3ca89e4906 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/quidem/MSQQuidemTest.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/quidem/MSQQuidemTest.java
@@ -19,15 +19,17 @@
 
 package org.apache.druid.msq.quidem;
 
+import org.apache.druid.quidem.DruidQuidemCommandHandler;
 import org.apache.druid.quidem.DruidQuidemTestBase;
 import org.apache.druid.quidem.ProjectPathUtils;
+
 import java.io.File;
 
 public class MSQQuidemTest extends DruidQuidemTestBase
 {
   public MSQQuidemTest()
   {
-    super();
+    super(new DruidQuidemCommandHandler());
   }
 
   @Override
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/AbstractMSQComponentSupplierDelegate.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/AbstractMSQComponentSupplierDelegate.java
index 42264ac46ba3..65634365dd62 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/AbstractMSQComponentSupplierDelegate.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/AbstractMSQComponentSupplierDelegate.java
@@ -19,8 +19,6 @@
 
 package org.apache.druid.msq.test;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.google.inject.Injector;
 import org.apache.druid.guice.IndexingServiceTuningConfigModule;
 import org.apache.druid.guice.JoinableFactoryModule;
 import org.apache.druid.initialization.DruidModule;
@@ -29,7 +27,6 @@
 import org.apache.druid.msq.guice.MSQIndexingModule;
 import org.apache.druid.msq.sql.MSQTaskSqlEngine;
 import org.apache.druid.msq.test.CalciteMSQTestsHelper.MSQTestModule;
-import org.apache.druid.server.QueryLifecycleFactory;
 import org.apache.druid.sql.calcite.run.SqlEngine;
 import org.apache.druid.sql.calcite.util.DruidModuleCollection;
 import org.apache.druid.sql.calcite.util.SqlTestFramework.QueryComponentSupplier;
@@ -61,12 +58,9 @@ public DruidModule getCoreModule()
   }
 
   @Override
-  public SqlEngine createEngine(
-      QueryLifecycleFactory qlf,
-      ObjectMapper queryJsonMapper,
-      Injector injector)
+  public Class<? extends SqlEngine> getSqlEngineClass()
   {
-    return injector.getInstance(MSQTaskSqlEngine.class);
+    return MSQTaskSqlEngine.class;
   }
 
   @Override
@@ -74,4 +68,5 @@ public Boolean isExplainSupported()
   {
     return false;
   }
+
 }
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/AllDruidEnginesComponentSupplier.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/AllDruidEnginesComponentSupplier.java
new file mode 100644
index 000000000000..62799295908a
--- /dev/null
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/AllDruidEnginesComponentSupplier.java
@@ -0,0 +1,32 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.msq.test;
+
+import org.apache.druid.sql.calcite.MultiComponentSupplier;
+import org.apache.druid.sql.calcite.MultiComponentSupplier.ComponentSuppliers;
+import org.apache.druid.sql.calcite.util.SqlTestFramework.StandardComponentSupplier;
+
+@ComponentSuppliers({
+    StandardComponentSupplier.class,
+    DartComponentSupplier.class,
+    StandardMSQComponentSupplier.class})
+public class AllDruidEnginesComponentSupplier extends MultiComponentSupplier
+{
+}
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/CalciteMSQTestsHelper.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/CalciteMSQTestsHelper.java
index 58f5a7b30624..b287458cf6b1 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/CalciteMSQTestsHelper.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/CalciteMSQTestsHelper.java
@@ -45,12 +45,8 @@
 import org.apache.druid.msq.guice.MSQExternalDataSourceModule;
 import org.apache.druid.msq.guice.MSQIndexingModule;
 import org.apache.druid.msq.querykit.DataSegmentProvider;
-import org.apache.druid.query.DruidProcessingConfig;
 import org.apache.druid.query.ForwardingQueryProcessingPool;
 import org.apache.druid.query.QueryProcessingPool;
-import org.apache.druid.query.groupby.GroupByQueryConfig;
-import org.apache.druid.query.groupby.GroupByQueryRunnerTest;
-import org.apache.druid.query.groupby.GroupingEngine;
 import org.apache.druid.query.groupby.TestGroupByBuffers;
 import org.apache.druid.segment.CompleteSegment;
 import org.apache.druid.segment.TestIndex;
@@ -98,15 +94,6 @@ public void configure(Binder binder)
       {
       }).annotatedWith(Self.class).toInstance(ImmutableSet.of(NodeRole.PEON));
 
-      DruidProcessingConfig druidProcessingConfig = new DruidProcessingConfig()
-      {
-        @Override
-        public String getFormatString()
-        {
-          return "test";
-        }
-      };
-      binder.bind(DruidProcessingConfig.class).toInstance(druidProcessingConfig);
       binder.bind(QueryProcessingPool.class)
             .toInstance(new ForwardingQueryProcessingPool(Execs.singleThreaded("Test-runner-processing-pool")));
 
@@ -174,7 +161,6 @@ public Supplier<ResourceHolder<CompleteSegment>> fetchSegment(
         CompleteSegment a = walker.getSegment(segmentId);
         return () -> new ReferenceCountingResourceHolder<>(a, Closer.create());
       }
-
     }
 
     @Provides
@@ -182,18 +168,6 @@ public DataServerQueryHandlerFactory provideDataServerQueryHandlerFactory()
     {
       return getTestDataServerQueryHandlerFactory();
     }
-
-    @Provides
-    @LazySingleton
-    GroupingEngine getGroupingEngine(GroupByQueryConfig groupByQueryConfig, TestGroupByBuffers groupByBuffers)
-    {
-      GroupingEngine groupingEngine = GroupByQueryRunnerTest.makeQueryRunnerFactory(
-          groupByQueryConfig,
-          groupByBuffers
-      ).getGroupingEngine();
-      return groupingEngine;
-    }
-
   }
 
   @Deprecated
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/DartComponentSupplier.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/DartComponentSupplier.java
index 7cfac91a4ce5..9beabe7f6905 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/DartComponentSupplier.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/DartComponentSupplier.java
@@ -19,9 +19,7 @@
 
 package org.apache.druid.msq.test;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.inject.Binder;
-import com.google.inject.Injector;
 import com.google.inject.Provides;
 import org.apache.druid.collections.NonBlockingPool;
 import org.apache.druid.discovery.DruidNodeDiscoveryProvider;
@@ -41,7 +39,6 @@
 import org.apache.druid.query.TestBufferPool;
 import org.apache.druid.rpc.ServiceClientFactory;
 import org.apache.druid.rpc.guice.ServiceClientModule;
-import org.apache.druid.server.QueryLifecycleFactory;
 import org.apache.druid.sql.avatica.DartDruidMeta;
 import org.apache.druid.sql.avatica.DruidMeta;
 import org.apache.druid.sql.calcite.TempDirProducer;
@@ -90,12 +87,9 @@ public DruidModule getOverrideModule()
   }
 
   @Override
-  public SqlEngine createEngine(
-      QueryLifecycleFactory qlf,
-      ObjectMapper queryJsonMapper,
-      Injector injector)
+  public Class<? extends SqlEngine> getSqlEngineClass()
   {
-    return injector.getInstance(DartSqlEngine.class);
+    return DartSqlEngine.class;
   }
 
   static class DartTestCoreModule implements DruidModule
diff --git a/processing/src/main/java/org/apache/druid/concurrent/Threads.java b/processing/src/main/java/org/apache/druid/concurrent/Threads.java
index 5dcb57c5cc14..825f4bfa23d4 100644
--- a/processing/src/main/java/org/apache/druid/concurrent/Threads.java
+++ b/processing/src/main/java/org/apache/druid/concurrent/Threads.java
@@ -55,7 +55,20 @@ public static void sleepFor(long sleepTime, TimeUnit unit) throws InterruptedExc
     }
   }
 
-  private Threads()
+  /**
+   * Temporarily renames the thread.
+   *
+   * Preferred usage should be via try-with-resources clauses.
+   *
+   * @return a {@link AutoCloseable} to rename the thread back to its original name.
+   */
+  public static AutoCloseable withThreadName(String name)
   {
+    final Thread thread = Thread.currentThread();
+    final String oldThreadName = thread.getName();
+    thread.setName(name);
+    return () -> {
+      thread.setName(oldThreadName);
+    };
   }
 }
diff --git a/processing/src/main/java/org/apache/druid/initialization/DruidModule.java b/processing/src/main/java/org/apache/druid/initialization/DruidModule.java
index 45d663cf5ce3..643dcf5789ef 100644
--- a/processing/src/main/java/org/apache/druid/initialization/DruidModule.java
+++ b/processing/src/main/java/org/apache/druid/initialization/DruidModule.java
@@ -20,6 +20,10 @@
 package org.apache.druid.initialization;
 
 import com.fasterxml.jackson.databind.Module;
+import com.google.inject.Binder;
+import com.google.inject.Inject;
+import com.google.inject.Injector;
+import com.google.inject.util.Modules;
 import org.apache.druid.guice.annotations.ExtensionPoint;
 
 import java.util.Collections;
@@ -36,6 +40,35 @@
 @ExtensionPoint
 public interface DruidModule extends com.google.inject.Module
 {
+  static DruidModule override(com.google.inject.Module baseModule, com.google.inject.Module overrideGuiceModule)
+  {
+    return new DruidModule()
+    {
+      @SuppressWarnings("unused")
+      @Inject
+      public void injectMe(Injector injector)
+      {
+        injector.injectMembers(baseModule);
+        injector.injectMembers(overrideGuiceModule);
+      }
+
+      @Override
+      public void configure(Binder binder)
+      {
+        binder.install(Modules.override(baseModule).with(overrideGuiceModule));
+      }
+
+      @Override
+      public List<? extends Module> getJacksonModules()
+      {
+        if (baseModule instanceof DruidModule) {
+          return ((DruidModule) baseModule).getJacksonModules();
+        }
+        return Collections.emptyList();
+      }
+    };
+  }
+
   default List<? extends Module> getJacksonModules()
   {
     return Collections.emptyList();
diff --git a/processing/src/test/java/org/apache/druid/concurrent/ThreadsTest.java b/processing/src/test/java/org/apache/druid/concurrent/ThreadsTest.java
new file mode 100644
index 000000000000..a8924b55f670
--- /dev/null
+++ b/processing/src/test/java/org/apache/druid/concurrent/ThreadsTest.java
@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.concurrent;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class ThreadsTest
+{
+  @Test
+  public void testThreadRename() throws Exception
+  {
+    String oldName = Thread.currentThread().getName();
+    String newName = "testThreadRename-was:" + oldName;
+    try (AutoCloseable renameBack = Threads.withThreadName(newName)) {
+      assertEquals(newName, Thread.currentThread().getName());
+    }
+    assertEquals(oldName, Thread.currentThread().getName());
+  }
+}
diff --git a/processing/src/test/java/org/apache/druid/initialization/DruidModuleTest.java b/processing/src/test/java/org/apache/druid/initialization/DruidModuleTest.java
new file mode 100644
index 000000000000..3d83dcd7d09a
--- /dev/null
+++ b/processing/src/test/java/org/apache/druid/initialization/DruidModuleTest.java
@@ -0,0 +1,98 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.initialization;
+
+import com.fasterxml.jackson.databind.Module;
+import com.google.inject.Binder;
+import com.google.inject.Guice;
+import com.google.inject.Inject;
+import com.google.inject.Injector;
+import com.google.inject.Provides;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class DruidModuleTest
+{
+  @Test
+  public void testOverride()
+  {
+    Injector initInjector = Guice.createInjector(new LocalProviderModule(10));
+    DruidModule overrideModule = DruidModule.override(new LocalProviderModule(1), new LocalProviderModule(2));
+    initInjector.injectMembers(overrideModule);
+    Injector injector = Guice.createInjector(overrideModule);
+    Integer val = injector.getInstance(Integer.class);
+    assertEquals(12, val);
+  }
+
+  @Test
+  public void testOverrideJacksonModules()
+  {
+    Injector initInjector = Guice.createInjector(new LocalProviderModule(10));
+    DruidModule overrideModule = DruidModule.override(new LocalProviderModule(1), new LocalProviderModule(2));
+    initInjector.injectMembers(overrideModule);
+    List<? extends Module> jacksonModules = overrideModule.getJacksonModules();
+    // Even thru it was overridden, the base module should still provide these.
+    assertEquals(1, jacksonModules.size());
+  }
+
+  static class LocalProviderModule implements DruidModule
+  {
+    private int val;
+    private int baseVal = 0;
+
+    @Inject
+    public void injectInteger(Integer baseVal)
+    {
+      this.baseVal = baseVal;
+    }
+
+    public LocalProviderModule(int i)
+    {
+      val = i;
+    }
+
+    @Override
+    public void configure(Binder binder)
+    {
+    }
+
+    @Provides
+    public Integer getVal()
+    {
+      return val + baseVal;
+    }
+
+    @Override
+    public List<? extends Module> getJacksonModules()
+    {
+      List<? extends Module> li = new ArrayList<>();
+      for (int i = 0; i < val; i++) {
+        li.add(null);
+      }
+      return li;
+    }
+
+  }
+
+}
diff --git a/quidem-ut/src/main/java/org/apache/druid/quidem/ExposedAsBrokerQueryComponentSupplierWrapper.java b/quidem-ut/src/main/java/org/apache/druid/quidem/ExposedAsBrokerQueryComponentSupplierWrapper.java
index 3cbe797be40d..0a2e496b09a9 100644
--- a/quidem-ut/src/main/java/org/apache/druid/quidem/ExposedAsBrokerQueryComponentSupplierWrapper.java
+++ b/quidem-ut/src/main/java/org/apache/druid/quidem/ExposedAsBrokerQueryComponentSupplierWrapper.java
@@ -30,11 +30,9 @@
 import org.apache.druid.cli.CliBroker;
 import org.apache.druid.cli.QueryJettyServerInitializer;
 import org.apache.druid.client.BrokerSegmentWatcherConfig;
-import org.apache.druid.client.BrokerServerView;
 import org.apache.druid.client.DirectDruidClientFactory;
 import org.apache.druid.client.InternalQueryConfig;
 import org.apache.druid.client.QueryableDruidServer;
-import org.apache.druid.client.TimelineServerView;
 import org.apache.druid.client.selector.CustomTierSelectorStrategyConfig;
 import org.apache.druid.client.selector.ServerSelectorStrategy;
 import org.apache.druid.client.selector.TierSelectorStrategy;
@@ -42,7 +40,6 @@
 import org.apache.druid.curator.discovery.DiscoveryModule;
 import org.apache.druid.discovery.DruidNodeDiscoveryProvider;
 import org.apache.druid.guice.AnnouncerModule;
-import org.apache.druid.guice.BrokerProcessingModule;
 import org.apache.druid.guice.BrokerServiceModule;
 import org.apache.druid.guice.CoordinatorDiscoveryModule;
 import org.apache.druid.guice.ExpressionModule;
@@ -59,7 +56,6 @@
 import org.apache.druid.guice.SegmentWranglerModule;
 import org.apache.druid.guice.ServerViewModule;
 import org.apache.druid.guice.StartupLoggingModule;
-import org.apache.druid.guice.StorageNodeModule;
 import org.apache.druid.guice.annotations.Client;
 import org.apache.druid.guice.annotations.EscalatedClient;
 import org.apache.druid.guice.http.HttpClientModule;
@@ -78,12 +74,8 @@
 import org.apache.druid.server.BrokerQueryResource;
 import org.apache.druid.server.ClientInfoResource;
 import org.apache.druid.server.DruidNode;
-import org.apache.druid.server.SubqueryGuardrailHelper;
-import org.apache.druid.server.SubqueryGuardrailHelperProvider;
-import org.apache.druid.server.emitter.EmitterModule;
 import org.apache.druid.server.http.BrokerResource;
 import org.apache.druid.server.http.SelfDiscoveryResource;
-import org.apache.druid.server.initialization.AuthorizerMapperModule;
 import org.apache.druid.server.initialization.ExternalStorageAccessSecurityModule;
 import org.apache.druid.server.initialization.jetty.JettyServerInitializer;
 import org.apache.druid.server.initialization.jetty.JettyServerModule;
@@ -131,7 +123,6 @@ public DruidModule getCoreModule()
     modules.add(super.getCoreModule());
     modules.addAll(forServerModules());
 
-    modules.add(new BrokerProcessingModule());
     modules.addAll(brokerModules());
     modules.add(new QuidemCaptureModule());
 
@@ -181,7 +172,6 @@ private List<Module> forServerModules()
         new ExtensionsModule.SecondaryModule(),
         new DruidAuthModule(),
         new TLSCertificateCheckerModule(),
-        new EmitterModule(),
         HttpClientModule.global(),
         HttpClientModule.escalatedGlobal(),
         new HttpClientModule("druid.broker.http", Client.class, true),
@@ -189,7 +179,6 @@ private List<Module> forServerModules()
         new CuratorModule(),
         new AnnouncerModule(),
         new SegmentWriteOutMediumModule(),
-        new StorageNodeModule(),
         new JettyServerModule(),
         new ExpressionModule(),
         new DiscoveryModule(),
@@ -203,7 +192,6 @@ private List<Module> forServerModules()
         new JavaScriptModule(),
         new AuthenticatorModule(),
         new AuthorizerModule(),
-        new AuthorizerMapperModule(),
         new StartupLoggingModule(),
         new ExternalStorageAccessSecurityModule(),
         new ServiceClientModule(),
@@ -231,8 +219,6 @@ static List<? extends Module> brokerModules()
           binder.bindConstant().annotatedWith(Names.named("tlsServicePort")).to(8282);
           binder.bindConstant().annotatedWith(PruneLoadSpec.class).to(true);
 
-          binder.bind(TimelineServerView.class).to(BrokerServerView.class).in(LazySingleton.class);
-
           JsonConfigProvider.bind(binder, "druid.broker.select", TierSelectorStrategy.class);
           JsonConfigProvider.bind(binder, "druid.broker.select.tier.custom", CustomTierSelectorStrategyConfig.class);
           JsonConfigProvider.bind(binder, "druid.broker.balancer", ServerSelectorStrategy.class);
@@ -243,7 +229,6 @@ static List<? extends Module> brokerModules()
 
           binder.bind(BrokerQueryResource.class).in(LazySingleton.class);
           Jerseys.addResource(binder, BrokerQueryResource.class);
-          binder.bind(SubqueryGuardrailHelper.class).toProvider(SubqueryGuardrailHelperProvider.class);
           binder.bind(QueryCountStatsProvider.class).to(BrokerQueryResource.class).in(LazySingleton.class);
           binder.bind(SubqueryCountStatsProvider.class).toInstance(new SubqueryCountStatsProvider());
           Jerseys.addResource(binder, BrokerResource.class);
diff --git a/quidem-ut/src/test/java/org/apache/druid/quidem/QTest.java b/quidem-ut/src/test/java/org/apache/druid/quidem/QTest.java
index 83167a18a168..4eeb52ef7c61 100644
--- a/quidem-ut/src/test/java/org/apache/druid/quidem/QTest.java
+++ b/quidem-ut/src/test/java/org/apache/druid/quidem/QTest.java
@@ -31,7 +31,7 @@ public class QTest extends DruidQuidemTestBase
 {
   public QTest()
   {
-    super();
+    super(new DruidQuidemCommandHandler());
   }
 
   @Override
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/dart_with_datasets.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/dart_with_datasets.iq
deleted file mode 100644
index 65dbce0f087b..000000000000
--- a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/dart_with_datasets.iq
+++ /dev/null
@@ -1,13 +0,0 @@
-!set dartQueryId 00000000-0000-0000-0000-000000000000
-!use druidtest://?componentSupplier=StandardMSQComponentSupplier&datasets=sql/src/test/quidem/sampledataset
-!set outputformat mysql
-
-select count(1) from "rollup-tutorial";
-+--------+
-| EXPR$0 |
-+--------+
-|      9 |
-+--------+
-(1 row)
-
-!ok
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/testframework_all_engines_dataset.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/testframework_all_engines_dataset.iq
new file mode 100644
index 000000000000..dd085251ceec
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/testframework_all_engines_dataset.iq
@@ -0,0 +1,17 @@
+!set dartQueryId 00000000-0000-0000-0000-000000000000
+!use druidtest://?componentSupplier=AllDruidEnginesComponentSupplier&datasets=sql/src/test/quidem/sampledataset
+!set outputformat mysql
+
+select * from "rollup-tutorial";
++-------------------------+---------+---------+--------+-------+---------+
+| __time                  | srcIP   | dstIP   | bytes  | count | packets |
++-------------------------+---------+---------+--------+-------+---------+
+| 2018-01-01 01:01:00.000 | 1.1.1.1 | 2.2.2.2 |  35937 |     3 |     286 |
+| 2018-01-01 01:02:00.000 | 1.1.1.1 | 2.2.2.2 | 366260 |     2 |     415 |
+| 2018-01-01 01:03:00.000 | 1.1.1.1 | 2.2.2.2 |  10204 |     1 |      49 |
+| 2018-01-02 21:33:00.000 | 7.7.7.7 | 8.8.8.8 | 100288 |     2 |     161 |
+| 2018-01-02 21:35:00.000 | 7.7.7.7 | 8.8.8.8 |   2818 |     1 |      12 |
++-------------------------+---------+---------+--------+-------+---------+
+(5 rows)
+
+!ok
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/testframework_all_engines_disabled.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/testframework_all_engines_disabled.iq
new file mode 100644
index 000000000000..c9c6a633dee4
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/testframework_all_engines_disabled.iq
@@ -0,0 +1,20 @@
+!set dartQueryId 00000000-0000-0000-0000-000000000000
+!use druidtest://?componentSupplier=AllDruidEnginesComponentSupplier
+!set outputformat mysql
+
+!disabled StandardComponentSupplier not supported on native engine: scan with order-by
+
+select dim1 from foo order by dim1;
++------+
+| dim1 |
++------+
+|      |
+| 1    |
+| 10.1 |
+| 2    |
+| abc  |
+| def  |
++------+
+(6 rows)
+
+!ok
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/dart1.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/testframework_dart.iq
similarity index 100%
rename from quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/dart1.iq
rename to quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/testframework_dart.iq
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/example.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/testframework_example.iq
similarity index 100%
rename from quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/example.iq
rename to quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/testframework_example.iq
diff --git a/server/src/test/java/org/apache/druid/guice/ServiceInjectorBuilderTest.java b/server/src/test/java/org/apache/druid/guice/ServiceInjectorBuilderTest.java
new file mode 100644
index 000000000000..cc11b1bc0e5e
--- /dev/null
+++ b/server/src/test/java/org/apache/druid/guice/ServiceInjectorBuilderTest.java
@@ -0,0 +1,126 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.guice;
+
+import com.google.inject.Binder;
+import com.google.inject.Injector;
+import com.google.inject.Provides;
+import com.google.inject.util.Modules;
+import org.apache.druid.initialization.CoreInjectorBuilder;
+import org.apache.druid.initialization.DruidModule;
+import org.apache.druid.initialization.ServiceInjectorBuilder;
+import org.junit.jupiter.api.Test;
+
+import java.util.Properties;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class ServiceInjectorBuilderTest
+{
+  @Test
+  public void testNormalUsage()
+  {
+    Injector startupInjector = new StartupInjectorBuilder()
+        .withProperties(new Properties())
+        .build();
+
+    CoreInjectorBuilder coreBuilder = new CoreInjectorBuilder(startupInjector);
+    coreBuilder.ignoreLoadScopes();
+    coreBuilder.addModule(
+        new LocalProviderModule(1)
+    );
+
+    ServiceInjectorBuilder si = new ServiceInjectorBuilder(coreBuilder);
+    si.add(
+        new LocalProviderModule(2)
+    );
+    Injector injector = si.build();
+    Integer v = injector.getInstance(Integer.class);
+    assertEquals(2, v);
+  }
+
+  @Test
+  public void testOverrideBelow()
+  {
+    Injector startupInjector = new StartupInjectorBuilder()
+        .withProperties(new Properties())
+        .build();
+
+    CoreInjectorBuilder coreBuilder = new CoreInjectorBuilder(startupInjector);
+    coreBuilder.ignoreLoadScopes();
+    coreBuilder.addModule(
+        Modules.override(new LocalProviderModule(0))
+            .with(new LocalProviderModule(1))
+    );
+
+    ServiceInjectorBuilder si = new ServiceInjectorBuilder(coreBuilder);
+    si.add(
+        new LocalProviderModule(2)
+    );
+    Injector injector = si.build();
+    Integer v = injector.getInstance(Integer.class);
+    assertEquals(2, v);
+  }
+
+  @Test
+  public void testOverrideBoth()
+  {
+    Injector startupInjector = new StartupInjectorBuilder()
+        .withProperties(new Properties())
+        .build();
+
+    CoreInjectorBuilder coreBuilder = new CoreInjectorBuilder(startupInjector);
+    coreBuilder.ignoreLoadScopes();
+    coreBuilder.addModule(
+        Modules.override(new LocalProviderModule(0))
+            .with(new LocalProviderModule(1))
+    );
+
+    ServiceInjectorBuilder si = new ServiceInjectorBuilder(coreBuilder);
+    si.add(
+        Modules.override(new LocalProviderModule(-1))
+            .with(new LocalProviderModule(2))
+    );
+    Injector injector = si.build();
+    Integer v = injector.getInstance(Integer.class);
+    assertEquals(2, v);
+  }
+
+  static class LocalProviderModule implements DruidModule
+  {
+    private int val;
+
+    public LocalProviderModule(int i)
+    {
+      val = i;
+    }
+
+    @Override
+    public void configure(Binder binder)
+    {
+    }
+
+    @Provides
+    public Integer getVal()
+    {
+      return val;
+    }
+  }
+}
diff --git a/server/src/test/java/org/apache/druid/sql/calcite/util/datasets/InputSourceBasedTestDataset.java b/server/src/test/java/org/apache/druid/sql/calcite/util/datasets/InputSourceBasedTestDataset.java
index 39cd46d52ac3..d5fee57fde62 100644
--- a/server/src/test/java/org/apache/druid/sql/calcite/util/datasets/InputSourceBasedTestDataset.java
+++ b/server/src/test/java/org/apache/druid/sql/calcite/util/datasets/InputSourceBasedTestDataset.java
@@ -86,7 +86,8 @@ public IncrementalIndexSchema getIndexSchema()
         .withTimestampSpec(getDataSchema().getTimestampSpec())
         .withMetrics(getDataSchema().getAggregators())
         .withDimensionsSpec(getDataSchema().getDimensionsSpec())
-        .withRollup(false)
+        .withRollup(getDataSchema().getGranularitySpec().isRollup())
+        .withQueryGranularity(getDataSchema().getGranularitySpec().getQueryGranularity())
         .build();
   }
 
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidCalciteSchemaModule.java b/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidCalciteSchemaModule.java
index 26d038ef4a3b..14e1fc068824 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidCalciteSchemaModule.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidCalciteSchemaModule.java
@@ -22,7 +22,6 @@
 import com.google.inject.Binder;
 import com.google.inject.Module;
 import com.google.inject.Provides;
-import com.google.inject.Scopes;
 import com.google.inject.name.Named;
 import com.google.inject.name.Names;
 import org.apache.druid.guice.LazySingleton;
@@ -47,15 +46,15 @@ public void configure(Binder binder)
     binder.bind(DruidSchemaCatalog.class)
           .annotatedWith(Names.named(INCOMPLETE_SCHEMA))
           .toProvider(RootSchemaProvider.class)
-          .in(Scopes.SINGLETON);
+          .in(LazySingleton.class);
 
     // BrokerSegmentMetadataCache needs to listen to changes for incoming segments
     LifecycleModule.register(binder, BrokerSegmentMetadataCache.class);
 
-    binder.bind(DruidSchema.class).in(Scopes.SINGLETON);
-    binder.bind(SystemSchema.class).in(Scopes.SINGLETON);
-    binder.bind(InformationSchema.class).in(Scopes.SINGLETON);
-    binder.bind(LookupSchema.class).in(Scopes.SINGLETON);
+    binder.bind(DruidSchema.class).in(LazySingleton.class);
+    binder.bind(SystemSchema.class).in(LazySingleton.class);
+    binder.bind(InformationSchema.class).in(LazySingleton.class);
+    binder.bind(LookupSchema.class).in(LazySingleton.class);
 
     // Binder to inject different schema to Calcite
     SqlBindings.addSchema(binder, NamedDruidSchema.class);
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java b/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java
index 5a8ae5ba9a8d..96cd166b1565 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java
@@ -25,6 +25,7 @@
 import org.apache.druid.sql.calcite.table.DruidTable;
 
 import javax.inject.Inject;
+
 import java.util.Set;
 
 public class DruidSchema extends AbstractTableSchema
@@ -74,7 +75,7 @@ public Table getTable(String name)
   public Set<String> getTableNames()
   {
     if (druidSchemaManager != null) {
-      return druidSchemaManager.getTableNames();
+      return druidSchemaManager.getTableNames(segmentMetadataCache);
     } else {
       return catalogResolver.getTableNames(segmentMetadataCache.getDatasourceNames());
     }
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchemaManager.java b/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchemaManager.java
index 85808bb1af4a..4ea8dfb829cb 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchemaManager.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchemaManager.java
@@ -44,8 +44,8 @@ public interface DruidSchemaManager
   /**
    * Return all tables known to this schema manager. Deprecated because getting
    * all tables is never actually needed in the current code. Calcite asks for
-   * the information for a single table (via {@link #getTable(String)}, or
-   * the list of all table <i>names</i> (via {@link #getTableNames()}. This
+   * the information for a single table (via {@link #getTable(String, BrokerSegmentMetadataCache)}, or
+   * the list of all table <i>names</i> (via {@link #getTableNames(BrokerSegmentMetadataCache)}. This
    * method was originally used to allow Calcite's {@link
    * org.apache.calcite.schema.impl.AbstractSchema AbstractSchema} class to do
    * the lookup. The current code implements the operations directly. For
@@ -55,17 +55,12 @@ public interface DruidSchemaManager
   @Deprecated
   Map<String, DruidTable> getTables();
 
-  default DruidTable getTable(String name)
-  {
-    return getTables().get(name);
-  }
-
   default DruidTable getTable(String name, BrokerSegmentMetadataCache segmentMetadataCache)
   {
     return getTables().get(name);
   }
 
-  default Set<String> getTableNames()
+  default Set<String> getTableNames(BrokerSegmentMetadataCache segmentMetadataCache)
   {
     return getTables().keySet();
   }
diff --git a/sql/src/main/java/org/apache/druid/sql/http/SqlQuery.java b/sql/src/main/java/org/apache/druid/sql/http/SqlQuery.java
index 7b54ae39fadf..623570f3df23 100644
--- a/sql/src/main/java/org/apache/druid/sql/http/SqlQuery.java
+++ b/sql/src/main/java/org/apache/druid/sql/http/SqlQuery.java
@@ -195,4 +195,9 @@ public String toString()
            ", parameters=" + parameters +
            '}';
   }
+
+  public SqlQuery withQueryContext(Map<String, Object> newContext)
+  {
+    return new SqlQuery(query, resultFormat, header, typesHeader, sqlTypesHeader, newContext, parameters);
+  }
 }
diff --git a/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaTestDriver.java b/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaTestDriver.java
index 21e0cc7bd71a..df66887dfd4b 100644
--- a/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaTestDriver.java
+++ b/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaTestDriver.java
@@ -31,6 +31,7 @@
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.java.util.common.io.Closer;
 import org.apache.druid.server.DruidNode;
+import org.apache.druid.server.SpecificSegmentsQuerySegmentWalker;
 import org.apache.druid.sql.avatica.AvaticaMonitor;
 import org.apache.druid.sql.avatica.DruidAvaticaJsonHandler;
 import org.apache.druid.sql.avatica.DruidMeta;
@@ -86,7 +87,12 @@ public Connection connect(String url, Properties info) throws SQLException
       return server.getConnection(info);
     }
     catch (Exception e) {
-      throw new SQLException("Can't create testconnection", e);
+      if (e instanceof SQLException) {
+        throw (SQLException) e;
+      }
+      // We create an Error here so that the exception is certain to make it out of the Quidem runner because it
+      // captures SqlExceptions and makes the messages hard to find sometimes.
+      throw new Error("Can't create testconnection", e);
     }
   }
 
@@ -100,6 +106,7 @@ public DruidConnectionExtras getConnectionExtras(
         ObjectMapper objectMapper,
         DruidHookDispatcher druidHookDispatcher,
         @Named("isExplainSupported") Boolean isExplainSupported,
+        SpecificSegmentsQuerySegmentWalker walker,
         Injector injector
     )
     {
@@ -107,6 +114,7 @@ public DruidConnectionExtras getConnectionExtras(
           objectMapper,
           druidHookDispatcher,
           isExplainSupported,
+          walker,
           injector
       );
     }
@@ -131,7 +139,6 @@ public void close() throws IOException
     {
       closer.close();
     }
-
   }
 
   static class AvaticaJettyServer implements Closeable
diff --git a/sql/src/test/java/org/apache/druid/quidem/DruidConnectionExtras.java b/sql/src/test/java/org/apache/druid/quidem/DruidConnectionExtras.java
index fa46e5f9d342..c87e0c968795 100644
--- a/sql/src/test/java/org/apache/druid/quidem/DruidConnectionExtras.java
+++ b/sql/src/test/java/org/apache/druid/quidem/DruidConnectionExtras.java
@@ -22,6 +22,7 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.inject.Injector;
 import org.apache.druid.error.DruidException;
+import org.apache.druid.server.SpecificSegmentsQuerySegmentWalker;
 import org.apache.druid.sql.hook.DruidHookDispatcher;
 
 import java.sql.Connection;
@@ -30,6 +31,8 @@ public interface DruidConnectionExtras
 {
   ObjectMapper getObjectMapper();
 
+  SpecificSegmentsQuerySegmentWalker getWalker();
+
   DruidHookDispatcher getDruidHookDispatcher();
 
   boolean isExplainSupported();
@@ -41,18 +44,21 @@ class DruidConnectionExtrasImpl implements DruidConnectionExtras
     private final ObjectMapper objectMapper;
     private final DruidHookDispatcher druidHookDispatcher;
     private final boolean isExplainSupported;
+    private final SpecificSegmentsQuerySegmentWalker walker;
     private final Injector injector;
 
     public DruidConnectionExtrasImpl(
         ObjectMapper objectMapper,
         DruidHookDispatcher druidHookDispatcher,
         boolean isExplainSupported,
+        SpecificSegmentsQuerySegmentWalker walker,
         Injector injector
     )
     {
       this.objectMapper = objectMapper;
       this.druidHookDispatcher = druidHookDispatcher;
       this.isExplainSupported = isExplainSupported;
+      this.walker = walker;
       this.injector = injector;
     }
 
@@ -74,6 +80,12 @@ public boolean isExplainSupported()
       return isExplainSupported;
     }
 
+    @Override
+    public SpecificSegmentsQuerySegmentWalker getWalker()
+    {
+      return walker;
+    }
+
     @Override
     public Injector getInjector()
     {
diff --git a/sql/src/test/java/org/apache/druid/quidem/DruidQuidemCommandHandler.java b/sql/src/test/java/org/apache/druid/quidem/DruidQuidemCommandHandler.java
index 5bf6d18050f5..af52f4feb57e 100644
--- a/sql/src/test/java/org/apache/druid/quidem/DruidQuidemCommandHandler.java
+++ b/sql/src/test/java/org/apache/druid/quidem/DruidQuidemCommandHandler.java
@@ -21,6 +21,7 @@
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.collect.ImmutableList;
+import com.google.inject.Injector;
 import net.hydromatic.quidem.AbstractCommand;
 import net.hydromatic.quidem.Command;
 import net.hydromatic.quidem.CommandHandler;
@@ -33,8 +34,10 @@
 import org.apache.calcite.sql.SqlExplainFormat;
 import org.apache.calcite.sql.SqlExplainLevel;
 import org.apache.calcite.util.Util;
+import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.query.Query;
 import org.apache.druid.sql.calcite.BaseCalciteQueryTest;
+import org.apache.druid.sql.calcite.SqlTestFrameworkConfig;
 import org.apache.druid.sql.calcite.rel.DruidRel;
 import org.apache.druid.sql.hook.DruidHook;
 import org.apache.druid.sql.hook.DruidHook.HookKey;
@@ -46,6 +49,10 @@
 import java.sql.Statement;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static org.junit.Assume.assumeFalse;
 
 public class DruidQuidemCommandHandler implements CommandHandler
 {
@@ -70,15 +77,18 @@ public Command parseCommand(List<String> lines, List<String> content, String lin
     if (line.startsWith("msqPlan")) {
       return new MSQPlanCommand(lines, content);
     }
+    if (line.startsWith("disabled")) {
+      return new DisabledCommand(lines, content, line);
+    }
     return null;
   }
 
-  abstract static class AbstractPlanCommand extends AbstractCommand
+  public abstract static class AbstractPlanCommand extends AbstractCommand
   {
     private final List<String> content;
     private final List<String> lines;
 
-    AbstractPlanCommand(List<String> lines, List<String> content)
+    public AbstractPlanCommand(List<String> lines, List<String> content)
     {
       this.lines = ImmutableList.copyOf(lines);
       this.content = content;
@@ -98,6 +108,9 @@ public final void execute(Context context, boolean execute)
           executeExplain(context);
         }
         catch (Exception e) {
+          // This is packaged as an Error because Quidem grabs anything else and pushes it into the output file
+          // believing that you are wanting to validate the error.  By repackaging it, we get a nice failure in the
+          // runner instead
           throw new Error(e);
         }
       } else {
@@ -110,9 +123,7 @@ protected final <T> List<T> executeExplainCollectHookValues(Context context, Hoo
     {
       DruidHookDispatcher dhp = unwrapDruidHookDispatcher(context);
       List<T> logged = new ArrayList<>();
-      try (Closeable unhook = dhp.withHook(hook, (key, value) -> {
-        logged.add(value);
-      })) {
+      try (Closeable unhook = dhp.withHook(hook, (key, value) -> logged.add(value))) {
         executeExplainQuery(context);
       }
       return logged;
@@ -160,7 +171,9 @@ protected final DruidHookDispatcher unwrapDruidHookDispatcher(Context context)
     protected abstract void executeExplain(Context context) throws Exception;
   }
 
-  /** Command that prints the plan for the current query. */
+  /**
+   * Command that prints the plan for the current query.
+   */
   static class NativePlanCommand extends AbstractPlanCommand
   {
     NativePlanCommand(List<String> lines, List<String> content)
@@ -304,6 +317,61 @@ public String getCollectedHintsAsString()
     }
   }
 
+  /**
+   * Usage:
+   * <pre>
+   * !disabled StandardComponentSupplier reason for disabling
+   * </pre>
+   */
+  static class DisabledCommand extends AbstractCommand
+  {
+    private String supplierName;
+    private String message;
+    private Pattern DISABLED_PATTERN = Pattern.compile("disabled\\s+([\\w\\d]+)(\\s+([^\\s].+))?\\s*");
+
+    private final List<String> content;
+    private final List<String> lines;
+
+    DisabledCommand(List<String> lines, List<String> content, String line)
+    {
+      super();
+      this.lines = ImmutableList.copyOf(lines);
+      this.content = content;
+      Matcher m = DISABLED_PATTERN.matcher(line);
+      if (!m.matches()) {
+        throw new IllegalArgumentException("usage: !disabled <supplier> [<reason>]");
+      }
+      supplierName = m.group(1);
+      message = buildMessage(supplierName, m.group(3));
+    }
+
+    private static String buildMessage(String supplierName, String message)
+    {
+      return StringUtils.format("Test disabled on supplier [%s]. Reason: [%s]", supplierName, message);
+    }
+
+    @Override
+    public final void execute(Context context, boolean execute)
+    {
+      if (execute) {
+        try {
+          Injector injector = DruidConnectionExtras.unwrapOrThrow(context.connection()).getInjector();
+          SqlTestFrameworkConfig cfg = injector.getInstance(SqlTestFrameworkConfig.class);
+          assumeFalse(message, cfg.componentSupplier.getSimpleName().equals(supplierName));
+        }
+        catch (Exception e) {
+          // This is packaged as an Error because Quidem grabs anything else and pushes it into the output file
+          // believing that you are wanting to validate the error.  By repackaging it, we get a nice failure in the
+          // runner instead
+          throw new Error(e);
+        }
+      } else {
+        context.echo(content);
+      }
+      context.echo(lines);
+    }
+  }
+
   static class ConvertedPlanCommand extends AbstractRelPlanCommand
   {
     ConvertedPlanCommand(List<String> lines, List<String> content)
@@ -311,6 +379,7 @@ static class ConvertedPlanCommand extends AbstractRelPlanCommand
       super(lines, content, DruidHook.CONVERTED_PLAN);
     }
   }
+
   static class MSQPlanCommand extends AbstractStringCaptureCommand
   {
     MSQPlanCommand(List<String> lines, List<String> content)
diff --git a/sql/src/test/java/org/apache/druid/quidem/DruidQuidemConnectionFactory.java b/sql/src/test/java/org/apache/druid/quidem/DruidQuidemConnectionFactory.java
index b9a7963f4d80..6a955caa4891 100644
--- a/sql/src/test/java/org/apache/druid/quidem/DruidQuidemConnectionFactory.java
+++ b/sql/src/test/java/org/apache/druid/quidem/DruidQuidemConnectionFactory.java
@@ -19,15 +19,24 @@
 
 package org.apache.druid.quidem;
 
+import com.google.inject.Injector;
 import net.hydromatic.quidem.Quidem.ConnectionFactory;
 import net.hydromatic.quidem.Quidem.PropertyHandler;
+import org.apache.druid.sql.calcite.run.SqlEngine;
+import org.apache.druid.sql.calcite.util.SqlTestFramework.QueryComponentSupplier;
+import org.apache.http.client.utils.URIBuilder;
+
+import java.net.URI;
 import java.sql.Connection;
 import java.sql.DriverManager;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.Properties;
 
 public class DruidQuidemConnectionFactory implements ConnectionFactory, PropertyHandler
 {
   private Properties props = new Properties();
+  private Map<String, String> envs = new HashMap<>();
 
   public DruidQuidemConnectionFactory()
   {
@@ -38,12 +47,52 @@ public DruidQuidemConnectionFactory()
   @Override
   public Connection connect(String name, boolean reference) throws Exception
   {
-    if (name.startsWith("druidtest://")) {
-      return DriverManager.getConnection(name, props);
+    URI uri = URI.create(name);
+    if (uri.getScheme().endsWith("test")) {
+      // This property will be set by DruidQuidemTestBase to select the supplier
+      // for MultiComponentSupplier backed tests.
+      // note: caching will be based on the effective config: so if the same
+      // supplier is used from different MultiComponentSupplier it will be
+      // shared.
+      String customSupplier = props.getProperty("componentSupplier");
+      if (customSupplier != null) {
+        URIBuilder builder = new URIBuilder(uri);
+        builder.addParameter("componentSupplier", customSupplier);
+        builder.setHost("");
+        name = builder.build().toString();
+      }
+      Connection connection = DriverManager.getConnection(name, props);
+      envs = buildEnvsForConnection(connection);
+      return connection;
     }
     throw new RuntimeException("unknown connection '" + name + "'");
   }
 
+  private static Map<String, String> buildEnvsForConnection(Connection connection)
+  {
+    Map<String, String> envs = new HashMap<>();
+    DruidConnectionExtras extras = DruidConnectionExtras.unwrapOrThrow(connection);
+    Injector injector = extras.getInjector();
+    QueryComponentSupplier supplier = injector.getInstance(QueryComponentSupplier.class);
+    Class<? extends SqlEngine> engineClazz = supplier.getSqlEngineClass();
+    String engineName = engineClazz.getName();
+    boolean isDart = engineName.contains("Dart");
+    boolean isMSQ = engineName.contains("MSQ");
+    boolean isNative = engineName.contains("Native");
+
+    envs.put("isDart", String.valueOf(isDart));
+    envs.put("isMSQ", String.valueOf(isMSQ));
+    envs.put("isNative", String.valueOf(isNative));
+    envs.put("isTaskBased", String.valueOf(isDart || isMSQ));
+
+    return envs;
+  }
+
+  public Object envLookup(String key)
+  {
+    return envs.get(key);
+  }
+
   @Override
   public void onSet(String key, Object value)
   {
diff --git a/sql/src/test/java/org/apache/druid/quidem/DruidQuidemTestBase.java b/sql/src/test/java/org/apache/druid/quidem/DruidQuidemTestBase.java
index 8366d1dce9ef..7088d7b65953 100644
--- a/sql/src/test/java/org/apache/druid/quidem/DruidQuidemTestBase.java
+++ b/sql/src/test/java/org/apache/druid/quidem/DruidQuidemTestBase.java
@@ -19,6 +19,7 @@
 
 package org.apache.druid.quidem;
 
+import com.google.common.collect.Iterables;
 import com.google.common.io.Files;
 import net.hydromatic.quidem.CommandHandler;
 import net.hydromatic.quidem.Quidem;
@@ -29,10 +30,16 @@
 import org.apache.calcite.util.Util;
 import org.apache.commons.io.filefilter.TrueFileFilter;
 import org.apache.commons.io.filefilter.WildcardFileFilter;
+import org.apache.druid.concurrent.Threads;
+import org.apache.druid.error.DruidException;
 import org.apache.druid.java.util.common.FileUtils;
 import org.apache.druid.java.util.common.IAE;
 import org.apache.druid.java.util.common.RE;
 import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.sql.calcite.MultiComponentSupplier;
+import org.apache.druid.sql.calcite.SqlTestFrameworkConfig;
+import org.apache.druid.sql.calcite.util.SqlTestFramework.QueryComponentSupplier;
+import org.junit.AssumptionViolatedException;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -44,9 +51,14 @@
 import java.io.IOException;
 import java.io.Reader;
 import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
+import java.util.function.Function;
 
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -72,8 +84,7 @@
  * <li>Copy over the .iq.out to .iq to accept the changes</li>
  * </ol>
  *
- * To shorten the above 2 steps you can run the test with system property quiem.overwrite=true
- *
+ * To shorten the above 2 steps you can run the test with system property quidem.overwrite=true
  */
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 public abstract class DruidQuidemTestBase
@@ -91,7 +102,12 @@ public abstract class DruidQuidemTestBase
 
   private DruidQuidemRunner druidQuidemRunner;
 
-  public DruidQuidemTestBase()
+  public DruidQuidemTestBase(CommandHandler commandHandler)
+  {
+    this(new DruidQuidemRunner(commandHandler, Quidem::new));
+  }
+
+  public DruidQuidemTestBase(DruidQuidemRunner druidQuidemRunner)
   {
     String filterStr = System.getProperty(PROPERTY_FILTER, null);
     if (filterStr != null) {
@@ -100,58 +116,170 @@ public DruidQuidemTestBase()
       }
       filter = new WildcardFileFilter(filterStr);
     }
-    druidQuidemRunner = new DruidQuidemRunner(createCommandHandler());
+    this.druidQuidemRunner = druidQuidemRunner;
   }
 
-  /** Creates a command handler. */
-  protected CommandHandler createCommandHandler()
+  protected static class QuidemTestCaseConfiguration
   {
-    return new DruidQuidemCommandHandler();
+    final String fileName;
+    final String componentSupplierName;
+
+    public QuidemTestCaseConfiguration(String componentSupplierName, String fileName)
+    {
+      this.fileName = fileName;
+      this.componentSupplierName = componentSupplierName;
+    }
+
+    public String getTestName()
+    {
+      if (componentSupplierName == null) {
+        return fileName;
+      } else {
+        return StringUtils.format("%s@%s", fileName, componentSupplierName);
+      }
+    }
+
+    @Override
+    public String toString()
+    {
+      return getTestName();
+    }
   }
 
-  @ParameterizedTest
-  @MethodSource("getFileNames")
-  public void test(String testFileName) throws Exception
+  public List<QuidemTestCaseConfiguration> getTestConfigs() throws IOException
+  {
+    List<QuidemTestCaseConfiguration> ret = new ArrayList<>();
+    List<String> fileNames = getFileNames();
+    for (String file : fileNames) {
+      try {
+        ret.addAll(getConfigurationsFor(file));
+      }
+      catch (Exception e) {
+        throw DruidException.defensive(e, "While processing configurations for quidem file [%s]", file);
+      }
+    }
+    return ret;
+  }
+
+  private List<QuidemTestCaseConfiguration> getConfigurationsFor(String testFileName) throws IOException
   {
     File inFile = new File(getTestRoot(), testFileName);
+    List<QuidemTestCaseConfiguration> ret = new ArrayList<>();
+    for (Class<? extends QueryComponentSupplier> supplier : collectSuppliers(inFile)) {
+      String supplierName = supplier == null ? null : supplier.getSimpleName();
+      ret.add(new QuidemTestCaseConfiguration(supplierName, testFileName));
+    }
+    return ret;
+  }
+
+  private List<Class<? extends QueryComponentSupplier>> collectSuppliers(File inFile) throws IOException
+  {
+    Set<Class<MultiComponentSupplier>> metaSuppliers = collectMetaSuppliers(inFile);
+
+    switch (metaSuppliers.size()) {
+      case 0:
+        return Collections.singletonList(null);
+      case 1:
+        return MultiComponentSupplier.getSuppliers(Iterables.getOnlyElement(metaSuppliers));
+      default:
+        throw DruidException.defensive("Multiple MetaComponentSuppliers found [%s].", metaSuppliers);
+    }
+  }
+
+  private Set<Class<MultiComponentSupplier>> collectMetaSuppliers(File inFile) throws IOException
+  {
+    Set<Class<MultiComponentSupplier>> metaSuppliers = new HashSet<>();
+
+    for (String line : Files.readLines(inFile, StandardCharsets.UTF_8)) {
+      if (line.startsWith("!use")) {
+        String[] parts = line.split(" ");
+        if (parts.length == 2) {
+          SqlTestFrameworkConfig cfg = SqlTestFrameworkConfig.fromURL(parts[1]);
+          validateFrameworkConfig(cfg);
+          if (MultiComponentSupplier.class.isAssignableFrom(cfg.componentSupplier)) {
+            metaSuppliers.add((Class<MultiComponentSupplier>) cfg.componentSupplier);
+          }
+        }
+      }
+    }
+    return metaSuppliers;
+  }
+
+  @SuppressWarnings("unused")
+  protected void validateFrameworkConfig(SqlTestFrameworkConfig cfg)
+  {
+    // no-op
+  }
+
+  @ParameterizedTest
+  @MethodSource("getTestConfigs")
+  public void test(QuidemTestCaseConfiguration testConfig) throws Exception
+  {
+    final String testName = testConfig.getTestName();
+
+    File inFile = new File(getTestRoot(), testConfig.fileName);
+    final File outFile = new File(inFile.getParentFile(), testName + ".iq.out");
+    try (AutoCloseable closeable = Threads.withThreadName(testName)) {
+      druidQuidemRunner.run(inFile, outFile, testConfig.componentSupplierName);
+    }
+    catch (Error e) {
+      // This catch is needed to workaround the way Quidem currently handles AssumptionViolatedException
+      Throwable cause = e.getCause();
+      if (cause != null && cause instanceof AssumptionViolatedException) {
+        AssumptionViolatedException assumptionViolatedException = (AssumptionViolatedException) cause;
+        throw assumptionViolatedException;
+      }
+      throw e;
+    }
 
-    final File outFile = new File(inFile.getParentFile(), inFile.getName() + ".out");
-    druidQuidemRunner.run(inFile, outFile);
   }
 
   public static class DruidQuidemRunner
   {
     private CommandHandler commandHandler;
+    private Function<Config, Quidem> quidemMaker;
+
+    public DruidQuidemRunner()
+    {
+      this(new DruidQuidemCommandHandler(), Quidem::new);
+    }
 
-    public DruidQuidemRunner(CommandHandler commandHandler)
+    public DruidQuidemRunner(CommandHandler commandHandler, Function<Config, Quidem> quidemMaker)
     {
       this.commandHandler = commandHandler;
+      this.quidemMaker = quidemMaker;
     }
 
     public void run(File inFile) throws Exception
     {
       File outFile = new File(inFile.getParent(), inFile.getName() + ".out");
-      run(inFile, outFile);
+      run(inFile, outFile, null);
     }
 
-    public void run(File inFile, final File outFile) throws Exception
+    public void run(File inFile, final File outFile, String componentSupplier) throws Exception
     {
       FileUtils.mkdirp(outFile.getParentFile());
       try (Reader reader = Util.reader(inFile);
-          Writer writer = Util.printWriter(outFile);
-          Closer closer = new Closer()) {
+           Writer writer = Util.printWriter(outFile);
+           Closer closer = new Closer()) {
 
         DruidQuidemConnectionFactory connectionFactory = new DruidQuidemConnectionFactory();
+        if (componentSupplier != null) {
+          connectionFactory.onSet("componentSupplier", componentSupplier);
+        }
         ConfigBuilder configBuilder = Quidem.configBuilder()
             .withConnectionFactory(connectionFactory)
             .withPropertyHandler(connectionFactory)
+            .withEnv(connectionFactory::envLookup)
             .withCommandHandler(commandHandler);
 
         Config config = configBuilder
             .withReader(reader)
-            .withWriter(writer).build();
+            .withWriter(writer)
+            .withStackLimit(-1)
+            .build();
 
-        new Quidem(config).execute();
+        quidemMaker.apply(config).execute();
       }
       catch (Exception e) {
         throw new RE(e, "Encountered exception while running [%s]", inFile);
@@ -162,17 +290,33 @@ public void run(File inFile, final File outFile) throws Exception
       if (!diff.isEmpty()) {
         if (isOverwrite()) {
           Files.copy(outFile, inFile);
+        } else if (isUnsupportedComponentSupplier(diff, componentSupplier)) {
+          System.out.println("Skipping verification of unsupported componentSupplier " + componentSupplier);
         } else {
           fail("Files differ: " + outFile + " " + inFile + "\n" + diff);
         }
       }
     }
 
+
     public static boolean isOverwrite()
     {
       String property = System.getProperty(OVERWRITE_PROPERTY, "false");
       return property.length() == 0 || Boolean.valueOf(property);
     }
+
+    private static boolean isUnsupportedComponentSupplier(String diff, String componentSupplier)
+    {
+      return diff.contains(StringUtils.format(
+          "Unsupported componentSupplier[%s], skipping verification of diff.",
+          componentSupplier
+      ));
+    }
+  }
+
+  protected CommandHandler getCommandHandler()
+  {
+    return new DruidQuidemCommandHandler();
   }
 
   protected final List<String> getFileNames() throws IOException
@@ -183,8 +327,12 @@ protected final List<String> getFileNames() throws IOException
     if (!testRoot.exists()) {
       throw new FileNotFoundException(StringUtils.format("testRoot [%s] doesn't exists!", testRoot));
     }
-    for (File f : testRoot.listFiles(this::isTestIncluded)) {
-      ret.add(f.getName());
+
+    for (File f : Files.fileTraverser().breadthFirst(testRoot)) {
+      if (isTestIncluded(f)) {
+        Path relativePath = testRoot.toPath().relativize(f.toPath());
+        ret.add(relativePath.toString());
+      }
     }
     if (ret.isEmpty()) {
       throw new IAE(
@@ -200,8 +348,8 @@ protected final List<String> getFileNames() throws IOException
   private boolean isTestIncluded(File f)
   {
     return !f.isDirectory()
-        && f.getName().endsWith(IQ_SUFFIX)
-        && filter.accept(f);
+           && f.getName().endsWith(IQ_SUFFIX)
+           && filter.accept(f);
   }
 
   protected abstract File getTestRoot();
diff --git a/sql/src/test/java/org/apache/druid/quidem/SqlQuidemTest.java b/sql/src/test/java/org/apache/druid/quidem/SqlQuidemTest.java
index 9e6a965891ce..f9ae79925752 100644
--- a/sql/src/test/java/org/apache/druid/quidem/SqlQuidemTest.java
+++ b/sql/src/test/java/org/apache/druid/quidem/SqlQuidemTest.java
@@ -25,7 +25,7 @@ public class SqlQuidemTest extends DruidQuidemTestBase
 {
   public SqlQuidemTest()
   {
-    super();
+    super(new DruidQuidemCommandHandler());
   }
 
   @Override
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/BaseCalciteQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/BaseCalciteQueryTest.java
index 52605f04dce7..aa8542d92bef 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/BaseCalciteQueryTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/BaseCalciteQueryTest.java
@@ -1234,6 +1234,11 @@ public static <T> Query<?> recursivelyClearContext(final Query<T> query, ObjectM
       }
       final JsonNode newQueryNode = queryJsonMapper.valueToTree(newQuery);
       ((ObjectNode) newQueryNode).remove("context");
+      JsonNode fc = ((ObjectNode) newQueryNode).get("searchFilterContext");
+      if (fc != null) {
+        ((ObjectNode) fc).remove("nowMs");
+      }
+
       return queryJsonMapper.treeToValue(newQueryNode, Query.class);
     }
     catch (Exception e) {
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteIngestionDmlTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteIngestionDmlTest.java
index 3b4c864fc659..2484c2deaf7f 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteIngestionDmlTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteIngestionDmlTest.java
@@ -30,7 +30,6 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.inject.Binder;
-import com.google.inject.Injector;
 import org.apache.druid.data.input.AbstractInputSource;
 import org.apache.druid.data.input.InputFormat;
 import org.apache.druid.data.input.InputSplit;
@@ -48,7 +47,6 @@
 import org.apache.druid.query.aggregation.hyperloglog.HyperUniquesAggregatorFactory;
 import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.column.RowSignature;
-import org.apache.druid.server.QueryLifecycleFactory;
 import org.apache.druid.server.security.AuthConfig;
 import org.apache.druid.server.security.AuthenticationResult;
 import org.apache.druid.server.security.ResourceAction;
@@ -127,7 +125,7 @@ public class CalciteIngestionDmlTest extends BaseCalciteQueryTest
 
   protected boolean didTest = false;
 
-  static class IngestionDmlComponentSupplier extends StandardComponentSupplier
+  public static class IngestionDmlComponentSupplier extends StandardComponentSupplier
   {
     public IngestionDmlComponentSupplier(TempDirProducer tempFolderProducer)
     {
@@ -135,9 +133,9 @@ public IngestionDmlComponentSupplier(TempDirProducer tempFolderProducer)
     }
 
     @Override
-    public SqlEngine createEngine(QueryLifecycleFactory qlf, ObjectMapper queryJsonMapper, Injector injector)
+    public Class<? extends SqlEngine> getSqlEngineClass()
     {
-      return IngestionTestSqlEngine.INSTANCE;
+      return IngestionTestSqlEngine.class;
     }
 
     @Override
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteScanSignatureTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteScanSignatureTest.java
index 1f50b81b51ea..02a2a168034d 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteScanSignatureTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteScanSignatureTest.java
@@ -19,21 +19,20 @@
 
 package org.apache.druid.sql.calcite;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.collect.ImmutableList;
-import com.google.inject.Injector;
+import com.google.inject.Inject;
 import org.apache.calcite.rel.RelRoot;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.tools.ValidationException;
 import org.apache.druid.query.scan.ScanQuery;
 import org.apache.druid.segment.column.ColumnType;
-import org.apache.druid.server.QueryLifecycleFactory;
 import org.apache.druid.sql.calcite.CalciteScanSignatureTest.ScanSignatureComponentSupplier;
 import org.apache.druid.sql.calcite.filtration.Filtration;
 import org.apache.druid.sql.calcite.planner.PlannerContext;
 import org.apache.druid.sql.calcite.rel.DruidQuery;
 import org.apache.druid.sql.calcite.run.EngineFeature;
+import org.apache.druid.sql.calcite.run.NativeSqlEngine;
 import org.apache.druid.sql.calcite.run.QueryMaker;
 import org.apache.druid.sql.calcite.run.SqlEngine;
 import org.apache.druid.sql.calcite.util.CalciteTests;
@@ -116,22 +115,20 @@ public ScanSignatureComponentSupplier(TempDirProducer tempFolderProducer)
       super(tempFolderProducer);
     }
 
+
     @Override
-    public SqlEngine createEngine(
-        QueryLifecycleFactory qlf,
-        ObjectMapper queryJsonMapper,
-        Injector injector
-    )
+    public Class<? extends SqlEngine> getSqlEngineClass()
     {
-      // Create an engine that says yes to EngineFeature.SCAN_NEEDS_SIGNATURE.
-      return new ScanSignatureTestSqlEngine(super.createEngine(qlf, queryJsonMapper, injector));
+      return ScanSignatureTestSqlEngine.class;
     }
 
+    // Create an engine that says yes to EngineFeature.SCAN_NEEDS_SIGNATURE.
     private static class ScanSignatureTestSqlEngine implements SqlEngine
     {
       private final SqlEngine parent;
 
-      public ScanSignatureTestSqlEngine(final SqlEngine parent)
+      @Inject
+      public ScanSignatureTestSqlEngine(final NativeSqlEngine parent)
       {
         this.parent = parent;
       }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/IngestionTestSqlEngine.java b/sql/src/test/java/org/apache/druid/sql/calcite/IngestionTestSqlEngine.java
index 569598af1e4e..8cb2a974e6d1 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/IngestionTestSqlEngine.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/IngestionTestSqlEngine.java
@@ -20,6 +20,7 @@
 package org.apache.druid.sql.calcite;
 
 import com.google.common.collect.ImmutableList;
+import com.google.inject.Inject;
 import org.apache.calcite.rel.RelRoot;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
@@ -37,8 +38,7 @@
 
 public class IngestionTestSqlEngine implements SqlEngine
 {
-  public static final IngestionTestSqlEngine INSTANCE = new IngestionTestSqlEngine();
-
+  @Inject
   private IngestionTestSqlEngine()
   {
   }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/MultiComponentSupplier.java b/sql/src/test/java/org/apache/druid/sql/calcite/MultiComponentSupplier.java
new file mode 100644
index 000000000000..b6efbc9b351d
--- /dev/null
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/MultiComponentSupplier.java
@@ -0,0 +1,173 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.sql.calcite;
+
+import com.google.inject.Module;
+import org.apache.druid.error.DruidException;
+import org.apache.druid.guice.DruidInjectorBuilder;
+import org.apache.druid.initialization.DruidModule;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.query.QueryRunnerFactoryConglomerate;
+import org.apache.druid.query.lookup.LookupExtractorFactoryContainerProvider;
+import org.apache.druid.segment.join.JoinableFactoryWrapper;
+import org.apache.druid.server.SpecificSegmentsQuerySegmentWalker;
+import org.apache.druid.sql.calcite.run.SqlEngine;
+import org.apache.druid.sql.calcite.util.SqlTestFramework;
+import org.apache.druid.sql.calcite.util.SqlTestFramework.PlannerComponentSupplier;
+import org.apache.druid.sql.calcite.util.SqlTestFramework.QueryComponentSupplier;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+
+/**
+ * Multi supplier to run the same testcase against multiple suppliers.
+ *
+ * Usage:
+ *
+ * <pre>
+ * @ComponentSuppliers( {  RealSupplier1.class, RealSupplier2.class } )
+ * public class SomeSupplier extends MultiComponentSupplier {
+ * }
+ * </pre>
+ */
+public abstract class MultiComponentSupplier implements QueryComponentSupplier
+{
+  @Retention(RetentionPolicy.RUNTIME)
+  @Target(ElementType.TYPE)
+  public @interface ComponentSuppliers
+  {
+    Class<? extends QueryComponentSupplier>[] value();
+  }
+
+  private static final Map<Class<? extends QueryComponentSupplier>, Set<Class<? extends MultiComponentSupplier>>>
+      KNOWN_SUB_QUERY_COMPONENT_SUPPLIERS = new LinkedHashMap<>();
+
+  public static void registerComponentSupplier(Class<? extends MultiComponentSupplier> clazz)
+  {
+    final List<Class<? extends QueryComponentSupplier>> subSuppliers = getSuppliers(clazz);
+    for (Class<? extends QueryComponentSupplier> subSupplier : subSuppliers) {
+      KNOWN_SUB_QUERY_COMPONENT_SUPPLIERS.computeIfAbsent(subSupplier, ignore -> new LinkedHashSet<>()).add(clazz);
+    }
+  }
+
+  public static Set<Class<? extends MultiComponentSupplier>> findParentSuppliers(
+      Class<? extends QueryComponentSupplier> clazz
+  )
+  {
+    return KNOWN_SUB_QUERY_COMPONENT_SUPPLIERS.get(clazz);
+  }
+
+  public static List<Class<? extends QueryComponentSupplier>> getSuppliers(Class<? extends MultiComponentSupplier> clazz)
+  {
+    ComponentSuppliers a = clazz.getAnnotation(ComponentSuppliers.class);
+    if (a == null || a.value().length == 0) {
+      throw DruidException.defensive("No component suppliers found [%s].", clazz.getName());
+    }
+    return Arrays.asList(a.value());
+  }
+
+  private DruidException unsupportedException()
+  {
+    return DruidException.defensive("Unexpected call made to " + getClass().getName());
+  }
+
+  @Override
+  public void gatherProperties(Properties properties)
+  {
+    throw unsupportedException();
+  }
+
+  @Override
+  public DruidModule getCoreModule()
+  {
+    throw unsupportedException();
+  }
+
+  @Override
+  public DruidModule getOverrideModule()
+  {
+    throw unsupportedException();
+  }
+
+  @Override
+  public SpecificSegmentsQuerySegmentWalker addSegmentsToWalker(SpecificSegmentsQuerySegmentWalker walker)
+  {
+    throw unsupportedException();
+  }
+
+  @Override
+  public Class<? extends SqlEngine> getSqlEngineClass()
+  {
+    throw unsupportedException();
+  }
+
+  @Override
+  public JoinableFactoryWrapper createJoinableFactoryWrapper(LookupExtractorFactoryContainerProvider lookupProvider)
+  {
+    throw unsupportedException();
+  }
+
+  @Override
+  public void finalizeTestFramework(SqlTestFramework sqlTestFramework)
+  {
+    throw unsupportedException();
+  }
+
+  @Override
+  public PlannerComponentSupplier getPlannerComponentSupplier()
+  {
+    throw unsupportedException();
+  }
+
+  @Override
+  public void configureGuice(DruidInjectorBuilder injectorBuilder, List<Module> overrideModules)
+  {
+    throw unsupportedException();
+  }
+
+  @Override
+  public Boolean isExplainSupported()
+
+  {
+    throw unsupportedException();
+  }
+
+  @Override
+  public QueryRunnerFactoryConglomerate wrapConglomerate(QueryRunnerFactoryConglomerate conglomerate,
+      Closer resourceCloser)
+  {
+    throw unsupportedException();
+  }
+
+  @Override
+  public TempDirProducer getTempDirProducer()
+  {
+    throw unsupportedException();
+  }
+}
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/QTestCase.java b/sql/src/test/java/org/apache/druid/sql/calcite/QTestCase.java
index 01714525b664..67f5bf3c2eb7 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/QTestCase.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/QTestCase.java
@@ -25,7 +25,6 @@
 import org.apache.druid.java.util.common.FileUtils;
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.quidem.DruidQTestInfo;
-import org.apache.druid.quidem.DruidQuidemCommandHandler;
 import org.apache.druid.quidem.DruidQuidemTestBase;
 import org.apache.druid.quidem.DruidQuidemTestBase.DruidQuidemRunner;
 import org.apache.druid.sql.calcite.QueryTestRunner.QueryRunStep;
@@ -70,7 +69,7 @@ public void run()
             isValidTestCaseFile(testInfo.getIQFile());
           }
 
-          DruidQuidemRunner runner = new DruidQuidemTestBase.DruidQuidemRunner(new DruidQuidemCommandHandler());
+          DruidQuidemRunner runner = new DruidQuidemTestBase.DruidQuidemRunner();
           runner.run(testInfo.getIQFile());
         }
         catch (Exception e) {
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/SqlTestFrameworkConfig.java b/sql/src/test/java/org/apache/druid/sql/calcite/SqlTestFrameworkConfig.java
index 8758871c3841..87919839a02d 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/SqlTestFrameworkConfig.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/SqlTestFrameworkConfig.java
@@ -27,10 +27,10 @@
 import com.google.common.cache.LoadingCache;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;
+import org.apache.druid.error.DruidException;
 import org.apache.druid.java.util.common.IAE;
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.query.topn.TopNQueryConfig;
-import org.apache.druid.quidem.DruidAvaticaTestDriver;
 import org.apache.druid.server.QueryStackTests;
 import org.apache.druid.sql.calcite.util.CacheTestHelperModule.ResultCacheMode;
 import org.apache.druid.sql.calcite.util.FakeIndexTaskUtil;
@@ -63,11 +63,11 @@
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.nio.charset.StandardCharsets;
-import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -458,20 +458,15 @@ private Map<String, String> getNonDefaultMap()
     return map;
   }
 
-  public static SqlTestFrameworkConfig fromURL(String url) throws SQLException
+  public static SqlTestFrameworkConfig fromURL(String url)
   {
 
     Map<String, String> queryParams;
     queryParams = new HashMap<>();
     try {
       URI uri = new URI(url);
-      if (!DruidAvaticaTestDriver.SCHEME.equals(uri.getScheme())) {
-        throw new SQLException(
-            StringUtils.format("URI [%s] is invalid ; only scheme [%s] is supported.", url, DruidAvaticaTestDriver.SCHEME)
-        );
-      }
       if (uri.getHost() != null || uri.getPort() != -1) {
-        throw new SQLException(StringUtils.format("URI [%s] is invalid ; only query parameters are supported.", url));
+        throw DruidException.defensive("URI [%s] is invalid ; only query parameters are supported.", url);
       }
       List<NameValuePair> params = URLEncodedUtils.parse(uri, StandardCharsets.UTF_8);
       for (NameValuePair pair : params) {
@@ -480,13 +475,13 @@ public static SqlTestFrameworkConfig fromURL(String url) throws SQLException
       // possible caveat: duplicate entries overwrite earlier ones
     }
     catch (URISyntaxException e) {
-      throw new SQLException("Can't decode URI", e);
+      throw DruidException.defensive(e, "Can't decode URI");
     }
 
     return new SqlTestFrameworkConfig(queryParams);
   }
 
-  abstract static class ConfigOptionProcessor<T>
+  public abstract static class ConfigOptionProcessor<T>
   {
     final Class<? extends Annotation> annotationClass;
 
@@ -554,7 +549,21 @@ public Set<Class<? extends QueryComponentSupplier>> load(String pkg)
                       .includePackage(pkg)
                       .and(s -> s.contains("ComponentSupplier"))
               );
-          return new Reflections(cfg).getSubTypesOf(QueryComponentSupplier.class);
+          final Set<Class<? extends QueryComponentSupplier>> baseComponentClazzes =
+              new Reflections(cfg).getSubTypesOf(QueryComponentSupplier.class);
+          LinkedHashSet<Class<? extends QueryComponentSupplier>> retVal = new LinkedHashSet<>(baseComponentClazzes);
+
+          for (Class<? extends QueryComponentSupplier> baseClazz : baseComponentClazzes) {
+            if (MultiComponentSupplier.class.isAssignableFrom(baseClazz) && baseClazz != MultiComponentSupplier.class) {
+              final Class<? extends MultiComponentSupplier> multiClazz =
+                  (Class<? extends MultiComponentSupplier>) baseClazz;
+
+              MultiComponentSupplier.registerComponentSupplier(multiClazz);
+              retVal.addAll(MultiComponentSupplier.getSuppliers(multiClazz));
+            }
+          }
+
+          return retVal;
         }
       });
 
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/CalciteTests.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/CalciteTests.java
index cb3ceaf442d7..b2c63d3b18b7 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/util/CalciteTests.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/CalciteTests.java
@@ -291,7 +291,11 @@ public static QueryLifecycleFactory createMockQueryLifecycleFactory(
       final QueryRunnerFactoryConglomerate conglomerate
   )
   {
-    return QueryFrameworkUtils.createMockQueryLifecycleFactory(walker, conglomerate);
+    return QueryFrameworkUtils.createMockQueryLifecycleFactory(
+        walker,
+        conglomerate,
+        CalciteTests.TEST_AUTHORIZER_MAPPER
+    );
   }
 
   public static SqlStatementFactory createSqlStatementFactory(
@@ -396,6 +400,15 @@ NodeRole.COORDINATOR, new FakeDruidNodeDiscovery(ImmutableMap.of(NodeRole.COORDI
     return provider;
   }
 
+  public static SystemSchema createMockSystemSchema(
+      final DruidSchema druidSchema,
+      final SpecificSegmentsQuerySegmentWalker walker,
+      final AuthorizerMapper authorizerMapper
+  )
+  {
+    return createMockSystemSchema(druidSchema, new TestTimelineServerView(walker.getSegments()), authorizerMapper);
+  }
+
   public static SystemSchema createMockSystemSchema(
       final DruidSchema druidSchema,
       final TimelineServerView timelineServerView,
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/DruidModuleCollection.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/DruidModuleCollection.java
index 764f190e41bf..ec728df96808 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/util/DruidModuleCollection.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/DruidModuleCollection.java
@@ -70,12 +70,31 @@ public final void configure(Binder binder)
 
   public static DruidModule of(Module... modules)
   {
-    return new DruidModuleCollection(Arrays.asList(modules));
+    return of(Arrays.asList(modules));
   }
 
-  public static DruidModule of(List<Module> modules)
+  public static DruidModule of(List<? extends Module> modules)
   {
-    return new DruidModuleCollection(modules);
+    return new DruidModuleCollection(flatten(modules));
+  }
+
+  public static List<Module> flatten(Module... modules)
+  {
+    return flatten(Arrays.asList(modules));
+  }
+
+  public static List<Module> flatten(List<? extends Module> modules)
+  {
+    ArrayList<Module> flattenedModules = new ArrayList<>(modules.size());
+    for (Module module : modules) {
+      if (module instanceof DruidModuleCollection) {
+        DruidModuleCollection moduleCollection = (DruidModuleCollection) module;
+        flattenedModules.addAll(moduleCollection.subModules);
+      } else {
+        flattenedModules.add(module);
+      }
+    }
+    return flattenedModules;
   }
 
 }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/QueryFrameworkUtils.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/QueryFrameworkUtils.java
index f61f52343987..67b5b9d11e22 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/util/QueryFrameworkUtils.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/QueryFrameworkUtils.java
@@ -85,7 +85,8 @@ public class QueryFrameworkUtils
 
   public static QueryLifecycleFactory createMockQueryLifecycleFactory(
       final QuerySegmentWalker walker,
-      final QueryRunnerFactoryConglomerate conglomerate
+      final QueryRunnerFactoryConglomerate conglomerate,
+      final AuthorizerMapper authorizerMapper
   )
   {
     return new QueryLifecycleFactory(
@@ -95,7 +96,7 @@ public static QueryLifecycleFactory createMockQueryLifecycleFactory(
         new ServiceEmitter("dummy", "dummy", new NoopEmitter()),
         new NoopRequestLogger(),
         new AuthConfig(),
-        CalciteTests.TEST_AUTHORIZER_MAPPER,
+        authorizerMapper,
         Suppliers.ofInstance(new DefaultQueryConfig(ImmutableMap.of()))
     );
   }
@@ -179,7 +180,7 @@ public static DruidSchemaCatalog createMockRootSchema(
     );
   }
 
-  static DruidSchemaCatalog createMockRootSchema(
+  public static DruidSchemaCatalog createMockRootSchema(
       final PlannerConfig plannerConfig,
       final ViewManager viewManager,
       final AuthorizerMapper authorizerMapper,
@@ -243,7 +244,7 @@ public static DruidSchemaCatalog createMockRootSchema(
     );
   }
 
-  static DruidSchema createMockSchema(
+  public static DruidSchema createMockSchema(
       final Injector injector,
       final QueryRunnerFactoryConglomerate conglomerate,
       final SpecificSegmentsQuerySegmentWalker walker,
@@ -253,7 +254,7 @@ static DruidSchema createMockSchema(
   )
   {
     final BrokerSegmentMetadataCache cache = new BrokerSegmentMetadataCache(
-        createMockQueryLifecycleFactory(walker, conglomerate),
+        createMockQueryLifecycleFactory(walker, conglomerate, CalciteTests.TEST_AUTHORIZER_MAPPER),
         timelineServerView,
         BrokerSegmentMetadataCacheConfig.create(),
         CalciteTests.TEST_AUTHENTICATOR_ESCALATOR,
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
index e99550d08c15..7803b9082aae 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
@@ -28,7 +28,6 @@
 import com.google.inject.Injector;
 import com.google.inject.Module;
 import com.google.inject.Provides;
-import com.google.inject.TypeLiteral;
 import org.apache.druid.client.TestHttpClient;
 import org.apache.druid.client.TimelineServerView;
 import org.apache.druid.client.cache.Cache;
@@ -45,6 +44,7 @@
 import org.apache.druid.guice.SegmentWranglerModule;
 import org.apache.druid.guice.ServerModule;
 import org.apache.druid.guice.StartupInjectorBuilder;
+import org.apache.druid.guice.StorageNodeModule;
 import org.apache.druid.guice.annotations.Global;
 import org.apache.druid.guice.annotations.Merging;
 import org.apache.druid.guice.annotations.Self;
@@ -56,9 +56,7 @@
 import org.apache.druid.java.util.emitter.service.ServiceEmitter;
 import org.apache.druid.java.util.http.client.HttpClient;
 import org.apache.druid.math.expr.ExprMacroTable;
-import org.apache.druid.query.DefaultGenericQueryMetricsFactory;
 import org.apache.druid.query.DruidProcessingConfig;
-import org.apache.druid.query.GenericQueryMetricsFactory;
 import org.apache.druid.query.GlobalTableDataSource;
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
 import org.apache.druid.query.QueryRunnerTestHelper;
@@ -77,8 +75,6 @@
 import org.apache.druid.query.topn.TopNQueryConfig;
 import org.apache.druid.quidem.ProjectPathUtils;
 import org.apache.druid.quidem.TestSqlModule;
-import org.apache.druid.segment.DefaultColumnFormatConfig;
-import org.apache.druid.segment.column.ColumnConfig;
 import org.apache.druid.segment.join.JoinableFactoryWrapper;
 import org.apache.druid.segment.realtime.ChatHandlerProvider;
 import org.apache.druid.segment.realtime.NoopChatHandlerProvider;
@@ -87,7 +83,6 @@
 import org.apache.druid.server.LocalQuerySegmentWalker;
 import org.apache.druid.server.QueryLifecycle;
 import org.apache.druid.server.QueryLifecycleFactory;
-import org.apache.druid.server.QueryScheduler;
 import org.apache.druid.server.QueryStackTests;
 import org.apache.druid.server.SpecificSegmentsQuerySegmentWalker;
 import org.apache.druid.server.SubqueryGuardrailHelper;
@@ -128,7 +123,6 @@
 import org.apache.druid.utils.JvmUtils;
 
 import javax.inject.Named;
-
 import java.io.Closeable;
 import java.io.File;
 import java.io.IOException;
@@ -201,6 +195,8 @@ public interface QueryComponentSupplier extends Closeable
      */
     void gatherProperties(Properties properties);
 
+    Class<? extends SqlEngine> getSqlEngineClass();
+
     SpecificSegmentsQuerySegmentWalker addSegmentsToWalker(SpecificSegmentsQuerySegmentWalker walker);
 
     /**
@@ -213,12 +209,6 @@ public interface QueryComponentSupplier extends Closeable
      */
     DruidModule getOverrideModule();
 
-    SqlEngine createEngine(
-        QueryLifecycleFactory qlf,
-        ObjectMapper objectMapper,
-        Injector injector
-    );
-
     default CatalogResolver createCatalogResolver()
     {
       return CatalogResolver.NULL_RESOLVER;
@@ -226,8 +216,6 @@ default CatalogResolver createCatalogResolver()
 
     /**
      * Configure the JSON mapper.
-     *
-     * @see #configureGuice(DruidInjectorBuilder) for the preferred solution.
      */
     @Deprecated
     default void configureJsonMapper(ObjectMapper mapper)
@@ -239,6 +227,7 @@ default void configureJsonMapper(ObjectMapper mapper)
     void finalizeTestFramework(SqlTestFramework sqlTestFramework);
 
     PlannerComponentSupplier getPlannerComponentSupplier();
+
     @Override
     default void close() throws IOException
     {
@@ -292,15 +281,6 @@ public SpecificSegmentsQuerySegmentWalker addSegmentsToWalker(SpecificSegmentsQu
       return delegate.addSegmentsToWalker(walker);
     }
 
-    @Override
-    public SqlEngine createEngine(
-        QueryLifecycleFactory qlf,
-        ObjectMapper objectMapper,
-        Injector injector)
-    {
-      return delegate.createEngine(qlf, objectMapper, injector);
-    }
-
     @Override
     public void configureJsonMapper(ObjectMapper mapper)
     {
@@ -338,8 +318,10 @@ public Boolean isExplainSupported()
     }
 
     @Override
-    public QueryRunnerFactoryConglomerate wrapConglomerate(QueryRunnerFactoryConglomerate conglomerate,
-        Closer resourceCloser)
+    public QueryRunnerFactoryConglomerate wrapConglomerate(
+        QueryRunnerFactoryConglomerate conglomerate,
+        Closer resourceCloser
+    )
     {
       return delegate.wrapConglomerate(conglomerate, resourceCloser);
     }
@@ -356,6 +338,12 @@ public DruidModule getOverrideModule()
       return delegate.getOverrideModule();
     }
 
+    @Override
+    public Class<? extends SqlEngine> getSqlEngineClass()
+    {
+      return delegate.getSqlEngineClass();
+    }
+
     @Override
     public TempDirProducer getTempDirProducer()
     {
@@ -417,23 +405,180 @@ public DruidModule getCoreModule()
           new LookylooModule(),
           new SegmentWranglerModule(),
           new ExpressionModule(),
-          new QueryRunnerFactoryModule(),
+          DruidModule.override(
+              new QueryRunnerFactoryModule(),
+              new Module()
+              {
+                @Override
+                public void configure(Binder binder)
+                {
+
+                }
+
+                @Provides
+                @Named("isExplainSupported")
+                public Boolean isExplainSupported(Builder builder)
+                {
+                  return builder.componentSupplier.isExplainSupported();
+                }
+
+                @Provides
+                public QueryComponentSupplier getQueryComponentSupplier(Builder builder)
+                {
+                  return builder.componentSupplier;
+                }
+
+                @Provides
+                @LazySingleton
+                GroupByQueryMetricsFactory groupByQueryMetricsFactory()
+                {
+                  return DefaultGroupByQueryMetricsFactory.instance();
+                }
+
+                @Provides
+                @LazySingleton
+                public TopNQueryConfig makeTopNQueryConfig(Builder builder)
+                {
+                  return new TopNQueryConfig()
+                  {
+                    @Override
+                    public int getMinTopNThreshold()
+                    {
+                      return builder.minTopNThreshold;
+                    }
+                  };
+                }
+
+                @Provides
+                public QueryWatcher getQueryWatcher()
+                {
+                  return QueryRunnerTestHelper.NOOP_QUERYWATCHER;
+                }
+              }
+          ),
           new BuiltInTypesModule(),
           new TestSqlModule(),
-          new ServerModule(),
+          DruidModule.override(
+              new ServerModule(),
+              new Module()
+              {
+                @Provides
+                @Self
+                @LazySingleton
+                public DruidNode makeSelfDruidNode()
+                {
+                  return new DruidNode("druid/broker", "local-test-host", false, 12345, 443, true, false);
+                }
+
+                @Override
+                public void configure(Binder binder)
+                {
+                }
+              }
+              ),
           new LifecycleModule(),
-          new QueryableModule(),
-          new SqlModule()
+          DruidModule.override(
+              new QueryableModule(),
+              binder -> {
+                TestRequestLogger testRequestLogger = new TestRequestLogger();
+                binder.bind(RequestLogger.class).toInstance(testRequestLogger);
+              }
+          ),
+          DruidModule.override(
+              new SqlModule(),
+              new Module()
+              {
+                @Override
+                public void configure(Binder binder)
+                {
+                }
+
+                @Provides
+                @LazySingleton
+                ViewManager createViewManager(Builder builder)
+                {
+                  return builder.componentSupplier.getPlannerComponentSupplier().createViewManager();
+                }
+
+                @Provides
+                @LazySingleton
+                private DruidSchema makeDruidSchema(
+                    final Injector injector,
+                    QueryRunnerFactoryConglomerate conglomerate,
+                    QuerySegmentWalker walker,
+                    Builder builder,
+                    TimelineServerView timelineServerView
+                )
+                {
+                  return QueryFrameworkUtils.createMockSchema(
+                      injector,
+                      conglomerate,
+                      (SpecificSegmentsQuerySegmentWalker) walker,
+                      builder.componentSupplier.getPlannerComponentSupplier().createSchemaManager(),
+                      builder.catalogResolver,
+                      timelineServerView
+                  );
+                }
+
+                @Provides
+                @LazySingleton
+                private SystemSchema makeSystemSchema(
+                    AuthorizerMapper authorizerMapper,
+                    DruidSchema druidSchema,
+                    TimelineServerView timelineServerView)
+                {
+                  return CalciteTests.createMockSystemSchema(druidSchema, timelineServerView, authorizerMapper);
+                }
+
+                @Provides
+                @LazySingleton
+                private TimelineServerView makeTimelineServerView(SpecificSegmentsQuerySegmentWalker walker)
+                {
+                  return new TestTimelineServerView(walker.getSegments());
+                }
+
+                @Provides
+                @LazySingleton
+                private LookupSchema makeLookupSchema(final Injector injector)
+                {
+                  return QueryFrameworkUtils.createMockLookupSchema(injector);
+                }
+
+                @Provides
+                @LazySingleton
+                private DruidSchemaCatalog makeCatalog(
+                    final PlannerConfig plannerConfig,
+                    final ViewManager viewManager,
+                    AuthorizerMapper authorizerMapper,
+                    DruidSchema druidSchema,
+                    SystemSchema systemSchema,
+                    LookupSchema lookupSchema,
+                    DruidOperatorTable createOperatorTable
+                )
+                {
+                  final DruidSchemaCatalog rootSchema = QueryFrameworkUtils.createMockRootSchema(
+                      plannerConfig,
+                      viewManager,
+                      authorizerMapper,
+                      druidSchema,
+                      systemSchema,
+                      lookupSchema,
+                      createOperatorTable
+                  );
+                  return rootSchema;
+                }
+              }
+          ),
+          new TestSetupModule(),
+          new TestSchemaSetupModule(),
+          new StorageNodeModule()
       );
     }
 
     @Override
     public DruidModule getOverrideModule()
     {
-      return DruidModuleCollection.of(
-          new TestSetupModule(),
-          new TestSchemaSetupModule()
-      );
+      return DruidModuleCollection.of();
     }
 
     /**
@@ -460,16 +605,9 @@ public SpecificSegmentsQuerySegmentWalker addSegmentsToWalker(SpecificSegmentsQu
     }
 
     @Override
-    public SqlEngine createEngine(
-        QueryLifecycleFactory qlf,
-        ObjectMapper objectMapper,
-        Injector injector
-    )
+    public Class<? extends SqlEngine> getSqlEngineClass()
     {
-      return new NativeSqlEngine(
-          qlf,
-          objectMapper
-      );
+      return NativeSqlEngine.class;
     }
 
     @Override
@@ -508,8 +646,10 @@ public Boolean isExplainSupported()
     }
 
     @Override
-    public QueryRunnerFactoryConglomerate wrapConglomerate(QueryRunnerFactoryConglomerate conglomerate,
-        Closer resourceCloser)
+    public QueryRunnerFactoryConglomerate wrapConglomerate(
+        QueryRunnerFactoryConglomerate conglomerate,
+        Closer resourceCloser
+    )
     {
       return conglomerate;
     }
@@ -648,6 +788,21 @@ public Builder withConfig(SqlTestFrameworkConfig config)
       this.config = config;
       return this;
     }
+
+    public QueryComponentSupplier getComponentSupplier()
+    {
+      return componentSupplier;
+    }
+
+    public CatalogResolver getCatalogResolver()
+    {
+      return catalogResolver;
+    }
+
+    public Closer getResourceCloser()
+    {
+      return resourceCloser;
+    }
   }
 
   /**
@@ -761,74 +916,52 @@ ChatHandlerProvider getChatHandlerProvider()
       return new NoopChatHandlerProvider();
     }
 
-    @Provides
-    GenericQueryMetricsFactory getGenericQueryMetricsFactory()
-    {
-      return DefaultGenericQueryMetricsFactory.instance();
-    }
-
     @Override
     public void configure(Binder binder)
     {
       binder.bind(DruidOperatorTable.class).in(LazySingleton.class);
       binder.bind(DataSegment.PruneSpecsHolder.class).toInstance(DataSegment.PruneSpecsHolder.DEFAULT);
-      binder.bind(DefaultColumnFormatConfig.class).toInstance(new DefaultColumnFormatConfig(null, null));
-
-      binder.bind(new TypeLiteral<NonBlockingPool<ByteBuffer>>(){})
-            .annotatedWith(Global.class)
-            .to(TestBufferPool.class);
-
-      binder.bind(new TypeLiteral<BlockingPool<ByteBuffer>>(){})
-            .annotatedWith(Merging.class)
-            .to(TestBufferPool.class);
-
-      TestRequestLogger testRequestLogger = new TestRequestLogger();
-      binder.bind(RequestLogger.class).toInstance(testRequestLogger);
     }
 
     @Provides
-    @Self
-    @LazySingleton
-    public DruidNode makeSelfDruidNode()
+    @Global
+    NonBlockingPool<ByteBuffer> getGlobalPool(TestBufferPool pool)
     {
-      return new DruidNode("druid/broker", "local-test-host", false, 12345, 443, true, false);
+      return pool;
     }
 
     @Provides
-    AuthorizerMapper getAuthorizerMapper()
+    @Merging
+    BlockingPool<ByteBuffer> getMergingPool(TestBufferPool pool)
     {
-      return AuthTestUtils.TEST_AUTHORIZER_MAPPER;
+      return pool;
     }
 
     @Provides
-    @LazySingleton
-    public TopNQueryConfig makeTopNQueryConfig(Builder builder)
-    {
-      return new TopNQueryConfig()
-      {
-        @Override
-        public int getMinTopNThreshold()
-        {
-          return builder.minTopNThreshold;
-        }
-      };
+    AuthorizerMapper getAuthorizerMapper()
+    {
+      return AuthTestUtils.TEST_AUTHORIZER_MAPPER;
     }
 
     @Provides
     @LazySingleton
     private GroupByResourcesReservationPool makeGroupByResourcesReservationPool(
         final GroupByQueryConfig config,
-        final TestGroupByBuffers bufferPools)
+        final TestGroupByBuffers bufferPools
+    )
     {
       return new GroupByResourcesReservationPool(bufferPools.getMergePool(), config);
     }
 
     @Provides
     @LazySingleton
-    private GroupingEngine makeGroupingEngine(final ObjectMapper mapper, final DruidProcessingConfig processingConfig,
+    private GroupingEngine makeGroupingEngine(
+        final ObjectMapper mapper,
+        final DruidProcessingConfig processingConfig,
         final GroupByStatsProvider statsProvider,
         final GroupByQueryConfig config,
-        final GroupByResourcesReservationPool groupByResourcesReservationPool)
+        final GroupByResourcesReservationPool groupByResourcesReservationPool
+    )
     {
       final Supplier<GroupByQueryConfig> configSupplier = Suppliers.ofInstance(config);
       return new GroupingEngine(
@@ -842,19 +975,12 @@ private GroupingEngine makeGroupingEngine(final ObjectMapper mapper, final Druid
       );
     }
 
-    @Provides
-    @LazySingleton
-    GroupByQueryMetricsFactory groupByQueryMetricsFactory()
-    {
-      return DefaultGroupByQueryMetricsFactory.instance();
-    }
-
-
     @Provides
     @LazySingleton
     @Merging
     GroupByResourcesReservationPool makeMergingGroupByResourcesReservationPool(
-        final GroupByResourcesReservationPool groupByResourcesReservationPool)
+        final GroupByResourcesReservationPool groupByResourcesReservationPool
+    )
     {
       return groupByResourcesReservationPool;
     }
@@ -895,17 +1021,11 @@ public QueryLifecycleFactory queryLifecycleFactory(final Injector injector)
     {
       return QueryFrameworkUtils.createMockQueryLifecycleFactory(
           injector.getInstance(QuerySegmentWalker.class),
-          injector.getInstance(QueryRunnerFactoryConglomerate.class)
+          injector.getInstance(QueryRunnerFactoryConglomerate.class),
+          injector.getInstance(AuthorizerMapper.class)
       );
     }
 
-    @Provides
-    @LazySingleton
-    ViewManager createViewManager(Builder builder)
-    {
-      return builder.componentSupplier.getPlannerComponentSupplier().createViewManager();
-    }
-
     @Provides
     SqlTestFrameworkConfig getTestConfig(Builder builder)
     {
@@ -918,91 +1038,10 @@ public URI getDruidTestURI(SqlTestFrameworkConfig config)
     {
       return config.getDruidTestURI();
     }
-
-    @Provides
-    @Named("isExplainSupported")
-    public Boolean isExplainSupported(Builder builder)
-    {
-      return builder.componentSupplier.isExplainSupported();
-    }
-
-    @Provides
-    public QueryWatcher getQueryWatcher()
-    {
-      return QueryRunnerTestHelper.NOOP_QUERYWATCHER;
-    }
   }
 
   public static class TestSchemaSetupModule implements DruidModule
   {
-
-    @Provides
-    @LazySingleton
-    private DruidSchema makeDruidSchema(
-        final Injector injector,
-        QueryRunnerFactoryConglomerate conglomerate,
-        QuerySegmentWalker walker,
-        Builder builder,
-        TimelineServerView timelineServerView)
-    {
-      return QueryFrameworkUtils.createMockSchema(
-          injector,
-          conglomerate,
-          (SpecificSegmentsQuerySegmentWalker) walker,
-          builder.componentSupplier.getPlannerComponentSupplier().createSchemaManager(),
-          builder.catalogResolver,
-          timelineServerView
-      );
-    }
-
-    @Provides
-    @LazySingleton
-    private SystemSchema makeSystemSchema(AuthorizerMapper authorizerMapper, DruidSchema druidSchema,
-        TimelineServerView timelineServerView)
-    {
-      return CalciteTests.createMockSystemSchema(druidSchema, timelineServerView, authorizerMapper);
-    }
-
-    @Provides
-    @LazySingleton
-    private TimelineServerView makeTimelineServerView(SpecificSegmentsQuerySegmentWalker walker)
-    {
-      return new TestTimelineServerView(walker.getSegments());
-    }
-
-
-    @Provides
-    @LazySingleton
-    private ColumnConfig getColumnConfig()
-    {
-      return ColumnConfig.DEFAULT;
-    }
-
-    @Provides
-    @LazySingleton
-    private LookupSchema makeLookupSchema(final Injector injector)
-    {
-      return QueryFrameworkUtils.createMockLookupSchema(injector);
-    }
-
-    @Provides
-    @LazySingleton
-    private DruidSchemaCatalog makeCatalog(final PlannerConfig plannerConfig, final ViewManager viewManager,
-        AuthorizerMapper authorizerMapper, DruidSchema druidSchema, SystemSchema systemSchema,
-        LookupSchema lookupSchema, DruidOperatorTable createOperatorTable)
-    {
-      final DruidSchemaCatalog rootSchema = QueryFrameworkUtils.createMockRootSchema(
-          plannerConfig,
-          viewManager,
-          authorizerMapper,
-          druidSchema,
-          systemSchema,
-          lookupSchema,
-          createOperatorTable
-      );
-      return rootSchema;
-    }
-
     @Provides
     @LazySingleton
     public SpecificSegmentsQuerySegmentWalker specificSegmentsQuerySegmentWalker(
@@ -1117,12 +1156,6 @@ public SubqueryGuardrailHelper makeSubqueryGuardrailHelper()
       return new SubqueryGuardrailHelper(null, JvmUtils.getRuntimeInfo().getMaxHeapSizeBytes(), 1);
     }
 
-    @Provides
-    public QueryScheduler makeQueryScheduler()
-    {
-      return QueryStackTests.DEFAULT_NOOP_SCHEDULER;
-    }
-
     @Override
     public void configure(Binder binder)
     {
@@ -1152,18 +1185,19 @@ private SqlTestFramework(Builder builder)
         // not the Druid node to which the module is scoped.
         .ignoreLoadScopes();
 
-    ArrayList<Module> overrideModules = new ArrayList<>(builder.overrideModules);
-
-    injectorBuilder.add(componentSupplier.getCoreModule());
+    injectorBuilder.addAll(DruidModuleCollection.flatten(componentSupplier.getCoreModule()));
     injectorBuilder.addModule(binder -> binder.bind(Builder.class).toInstance(builder));
-    overrideModules.add(componentSupplier.getOverrideModule());
+
+    ArrayList<Module> overrideModules = new ArrayList<>(builder.overrideModules);
+    overrideModules.addAll(DruidModuleCollection.flatten(componentSupplier.getOverrideModule()));
     builder.componentSupplier.configureGuice(injectorBuilder, overrideModules);
 
     ServiceInjectorBuilder serviceInjector = new ServiceInjectorBuilder(injectorBuilder);
     serviceInjector.addAll(overrideModules);
 
     this.injector = serviceInjector.build();
-    this.engine = builder.componentSupplier.createEngine(queryLifecycleFactory(), queryJsonMapper(), injector);
+    this.engine = injector.getInstance(componentSupplier.getSqlEngineClass());
+
     componentSupplier.configureJsonMapper(queryJsonMapper());
     componentSupplier.finalizeTestFramework(this);
   }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/TestDataBuilder.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/TestDataBuilder.java
index 4fd90a95c32b..309030f0280e 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/util/TestDataBuilder.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/TestDataBuilder.java
@@ -519,7 +519,7 @@ public Optional<Joinable> build(
       )
   );
 
-  private static List<InputRow> USER_VISIT_ROWS = ImmutableList.of(
+  public static List<InputRow> USER_VISIT_ROWS = ImmutableList.of(
       toRow(
           "2021-01-01T01:00:00Z",
           USER_VISIT_DIMS,
@@ -1158,12 +1158,12 @@ private static MapBasedInputRow toRow(String time, List<String> dimensions, Map<
     return new MapBasedInputRow(DateTimes.ISO_DATE_OPTIONAL_TIME.parse(time), dimensions, event);
   }
 
-  public static InputRow createRow(final ImmutableMap<String, ?> map)
+  public static InputRow createRow(final Map<String, ?> map)
   {
     return MapInputRowParser.parse(FOO_SCHEMA, (Map<String, Object>) map);
   }
 
-  public static InputRow createRow(final ImmutableMap<String, ?> map, InputRowSchema inputRowSchema)
+  public static InputRow createRow(final Map<String, ?> map, InputRowSchema inputRowSchema)
   {
     return MapInputRowParser.parse(inputRowSchema, (Map<String, Object>) map);
   }
diff --git a/sql/src/test/quidem/org.apache.druid.quidem.SqlQuidemTest/customdataset.iq b/sql/src/test/quidem/org.apache.druid.quidem.SqlQuidemTest/customdataset.iq
index dd3b0d43bcf4..d467cf3da286 100644
--- a/sql/src/test/quidem/org.apache.druid.quidem.SqlQuidemTest/customdataset.iq
+++ b/sql/src/test/quidem/org.apache.druid.quidem.SqlQuidemTest/customdataset.iq
@@ -6,7 +6,7 @@ select count(1) from "rollup-tutorial";
 +--------+
 | EXPR$0 |
 +--------+
-|      9 |
+|      5 |
 +--------+
 (1 row)
 

From 7d36e7979762954983d2814334f9dc27fd119685 Mon Sep 17 00:00:00 2001
From: jtuglu-netflix <jtuglu@netflix.com>
Date: Wed, 26 Mar 2025 14:08:08 -0700
Subject: [PATCH 57/99] Fix failing test in DimensionSchemaUtilsTest (#17832)

---
 .../msq/util/DimensionSchemaUtilsTest.java    | 24 ++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/util/DimensionSchemaUtilsTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/util/DimensionSchemaUtilsTest.java
index 0a4e3ddbd814..d068753d7189 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/util/DimensionSchemaUtilsTest.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/util/DimensionSchemaUtilsTest.java
@@ -25,14 +25,23 @@
 import org.apache.druid.data.input.impl.LongDimensionSchema;
 import org.apache.druid.data.input.impl.StringDimensionSchema;
 import org.apache.druid.error.DruidException;
+import org.apache.druid.java.util.emitter.EmittingLogger;
 import org.apache.druid.segment.AutoTypeColumnSchema;
 import org.apache.druid.segment.column.ColumnType;
+import org.apache.druid.server.metrics.NoopServiceEmitter;
 import org.junit.Assert;
+import org.junit.Before;
 import org.junit.Test;
 
 public class DimensionSchemaUtilsTest
 {
 
+  @Before
+  public void setup()
+  {
+    EmittingLogger.registerEmitter(new NoopServiceEmitter());
+  }
+
   @Test
   public void testSchemaScalars()
   {
@@ -179,19 +188,28 @@ public void testSchemaMvdMode()
         DruidException.class,
         () -> DimensionSchemaUtils.createDimensionSchema("x", ColumnType.LONG_ARRAY, false, ArrayIngestMode.MVD)
     );
-    Assert.assertEquals("Numeric arrays can only be ingested when 'arrayIngestMode' is set to 'array'. Current value of the parameter is[mvd]", t.getMessage());
+    Assert.assertEquals(
+        "Numeric arrays can only be ingested when 'arrayIngestMode' is set to 'array'. Current value of the parameter is[mvd]",
+        t.getMessage()
+    );
 
     t = Assert.assertThrows(
         DruidException.class,
         () -> DimensionSchemaUtils.createDimensionSchema("x", ColumnType.DOUBLE_ARRAY, false, ArrayIngestMode.MVD)
     );
-    Assert.assertEquals("Numeric arrays can only be ingested when 'arrayIngestMode' is set to 'array'. Current value of the parameter is[mvd]", t.getMessage());
+    Assert.assertEquals(
+        "Numeric arrays can only be ingested when 'arrayIngestMode' is set to 'array'. Current value of the parameter is[mvd]",
+        t.getMessage()
+    );
 
     t = Assert.assertThrows(
         DruidException.class,
         () -> DimensionSchemaUtils.createDimensionSchema("x", ColumnType.FLOAT_ARRAY, false, ArrayIngestMode.MVD)
     );
-    Assert.assertEquals("Numeric arrays can only be ingested when 'arrayIngestMode' is set to 'array'. Current value of the parameter is[mvd]", t.getMessage());
+    Assert.assertEquals(
+        "Numeric arrays can only be ingested when 'arrayIngestMode' is set to 'array'. Current value of the parameter is[mvd]",
+        t.getMessage()
+    );
   }
 
   @Test

From ec181a7b9ca14a9337d42cb7c524eb07514e57d7 Mon Sep 17 00:00:00 2001
From: Kashif Faraz <kashif.faraz@gmail.com>
Date: Thu, 27 Mar 2025 05:08:54 +0530
Subject: [PATCH 58/99] Improve performance of segment metadata cache on
 Overlord (#17785)

Description
-----------
#17653 introduces a cache for segment metadata on the Overlord.
This patch is a follow up to that to make the cache more robust, performant and debug-friendly.

Changes
---------
- Do not cache unused segments
This significantly reduces sync time in cases where the cluster has a lot of unused segments.
Unused segments are needed only during segment allocation to ensure that a duplicate ID is not allocated.
This is a rare DB query which is supported by sufficient indexes and thus need not be cached at the moment.
- Update cache directly when segments are marked as unused to avoid race conditions with DB sync.
- Fix NPE when using segment metadata cache with concurrent locks.
- Atomically update segment IDs and pending segments in a `HeapMemoryDatasourceSegmentCache`
using methods `syncSegmentIds()` and `syncPendingSegments()` rather than updating one by one.
This ensures that the locks are held for a shorter period and the update made to the cache is atomic.

Main updated classes
----------------------
- `IndexerMetadataStorageCoordinator`
- `OverlordDataSourcesResource`
- `HeapMemorySegmentMetadataCache`
- `HeapMemoryDatasourceSegmentCache`

Cleaner cache sync
--------------------
In every sync, the following steps are performed for each datasource:

- Retrieve ALL used segment IDs from metadata store
- Atomically update segment IDs in cache and determine list of segment IDs which need to be refreshed.
- Fetch payloads of segments that need to be refreshed
- Atomically update fetched payloads into the cache
- Fetch ALL pending segments
- Atomically update pending segments into the cache
- Clean up empty intervals from datasource caches
---
 .../actions/MarkSegmentsAsUnusedAction.java   |   2 +-
 .../RetrieveUpgradedFromSegmentIdsAction.java |   3 +
 .../RetrieveUpgradedToSegmentIdsAction.java   |   3 +
 .../http/OverlordDataSourcesResource.java     |  35 +-
 .../actions/SegmentAllocateActionTest.java    |   2 +-
 .../task/KillUnusedSegmentsTaskTest.java      |  17 +-
 .../indexing/overlord/TaskLifecycleTest.java  |  10 +-
 .../http/OverlordDataSourcesResourceTest.java |  12 +-
 ...TestIndexerMetadataStorageCoordinator.java |  82 +--
 .../apache/druid/common/utils/IdUtils.java    |  33 ++
 .../IndexerMetadataStorageCoordinator.java    |  36 +-
 .../IndexerSQLMetadataStorageCoordinator.java |  74 ++-
 .../metadata/SegmentsMetadataManager.java     |   2 +-
 .../metadata/SqlSegmentsMetadataManager.java  |  14 +-
 .../metadata/SqlSegmentsMetadataQuery.java    |  96 ++--
 .../CachedSegmentMetadataTransaction.java     |  91 +++-
 .../DatasourceSegmentMetadataReader.java      |   8 +-
 .../DatasourceSegmentMetadataWriter.java      |  41 +-
 .../segment/SegmentMetadataTransaction.java   |   3 +
 .../SqlSegmentMetadataTransaction.java        |  53 +-
 .../SqlSegmentMetadataTransactionFactory.java |   2 +-
 .../metadata/segment/cache/CacheStats.java    |  59 +++
 .../HeapMemoryDatasourceSegmentCache.java     | 393 ++++++++------
 .../cache/HeapMemorySegmentMetadataCache.java | 494 +++++++++---------
 .../druid/metadata/segment/cache/Metric.java  |  58 +-
 .../segment/cache/SegmentMetadataCache.java   |   7 +-
 .../metadata/segment/cache/SegmentRecord.java | 103 ++++
 .../segment/cache/SegmentSyncResult.java      |  57 ++
 .../server/http/DataSourcesResource.java      |  18 +-
 ...exerSQLMetadataStorageCoordinatorTest.java |  18 +-
 .../SqlSegmentsMetadataManagerTest.java       |  16 +-
 .../HeapMemoryDatasourceSegmentCacheTest.java | 415 +++++++--------
 .../HeapMemorySegmentMetadataCacheTest.java   | 107 ++--
 .../simulate/TestSegmentsMetadataManager.java |  22 +-
 34 files changed, 1443 insertions(+), 943 deletions(-)
 create mode 100644 server/src/main/java/org/apache/druid/metadata/segment/cache/CacheStats.java
 create mode 100644 server/src/main/java/org/apache/druid/metadata/segment/cache/SegmentRecord.java
 create mode 100644 server/src/main/java/org/apache/druid/metadata/segment/cache/SegmentSyncResult.java

diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/MarkSegmentsAsUnusedAction.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/MarkSegmentsAsUnusedAction.java
index a3341022f625..39bf0df10b23 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/MarkSegmentsAsUnusedAction.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/MarkSegmentsAsUnusedAction.java
@@ -62,7 +62,7 @@ public TypeReference<Integer> getReturnTypeReference()
   public Integer perform(Task task, TaskActionToolbox toolbox)
   {
     return toolbox.getIndexerMetadataStorageCoordinator()
-                  .markSegmentsAsUnusedWithinInterval(dataSource, interval);
+                  .markSegmentsWithinIntervalAsUnused(dataSource, interval, null);
   }
 
 }
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/RetrieveUpgradedFromSegmentIdsAction.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/RetrieveUpgradedFromSegmentIdsAction.java
index 2f86f568c450..3ffad3881f1c 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/RetrieveUpgradedFromSegmentIdsAction.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/RetrieveUpgradedFromSegmentIdsAction.java
@@ -22,6 +22,7 @@
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.core.type.TypeReference;
+import org.apache.druid.common.utils.IdUtils;
 import org.apache.druid.indexing.common.task.Task;
 
 import java.util.Set;
@@ -42,6 +43,8 @@ public RetrieveUpgradedFromSegmentIdsAction(
   {
     this.dataSource = dataSource;
     this.segmentIds = segmentIds;
+
+    IdUtils.getValidSegmentIds(dataSource, segmentIds);
   }
 
   @JsonProperty
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/RetrieveUpgradedToSegmentIdsAction.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/RetrieveUpgradedToSegmentIdsAction.java
index ab2547ecb7ef..493b16948638 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/RetrieveUpgradedToSegmentIdsAction.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/RetrieveUpgradedToSegmentIdsAction.java
@@ -22,6 +22,7 @@
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.core.type.TypeReference;
+import org.apache.druid.common.utils.IdUtils;
 import org.apache.druid.indexing.common.task.Task;
 
 import java.util.Set;
@@ -47,6 +48,8 @@ public RetrieveUpgradedToSegmentIdsAction(
   {
     this.dataSource = dataSource;
     this.segmentIds = segmentIds;
+
+    IdUtils.getValidSegmentIds(dataSource, segmentIds);
   }
 
   @JsonProperty
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/http/OverlordDataSourcesResource.java b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/http/OverlordDataSourcesResource.java
index bf9ff43981cd..94e4ef274a8e 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/http/OverlordDataSourcesResource.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/http/OverlordDataSourcesResource.java
@@ -25,8 +25,9 @@
 import com.sun.jersey.spi.container.ResourceFilters;
 import org.apache.druid.audit.AuditEntry;
 import org.apache.druid.audit.AuditManager;
+import org.apache.druid.common.utils.IdUtils;
 import org.apache.druid.error.DruidException;
-import org.apache.druid.error.InvalidInput;
+import org.apache.druid.indexing.overlord.IndexerMetadataStorageCoordinator;
 import org.apache.druid.indexing.overlord.TaskMaster;
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.java.util.common.logger.Logger;
@@ -49,7 +50,6 @@
 import javax.ws.rs.core.Context;
 import javax.ws.rs.core.MediaType;
 import javax.ws.rs.core.Response;
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
@@ -66,6 +66,7 @@ public class OverlordDataSourcesResource
   private static final Logger log = new Logger(OverlordDataSourcesResource.class);
 
   private final SegmentsMetadataManager segmentsMetadataManager;
+  private final IndexerMetadataStorageCoordinator metadataStorageCoordinator;
   private final TaskMaster taskMaster;
   private final AuditManager auditManager;
 
@@ -73,12 +74,14 @@ public class OverlordDataSourcesResource
   public OverlordDataSourcesResource(
       TaskMaster taskMaster,
       SegmentsMetadataManager segmentsMetadataManager,
+      IndexerMetadataStorageCoordinator metadataStorageCoordinator,
       AuditManager auditManager
   )
   {
     this.taskMaster = taskMaster;
     this.auditManager = auditManager;
     this.segmentsMetadataManager = segmentsMetadataManager;
+    this.metadataStorageCoordinator = metadataStorageCoordinator;
   }
 
   private interface SegmentUpdateOperation
@@ -109,8 +112,8 @@ public Response markAllSegmentsAsUnused(
       @Context HttpServletRequest req
   )
   {
-    SegmentUpdateOperation operation = () -> segmentsMetadataManager
-        .markAsUnusedAllSegmentsInDataSource(dataSourceName);
+    SegmentUpdateOperation operation =
+        () -> metadataStorageCoordinator.markAllSegmentsAsUnused(dataSourceName);
     final Response response = performSegmentUpdate(dataSourceName, operation);
 
     final int responseCode = response.getStatus();
@@ -147,18 +150,10 @@ public Response markNonOvershadowedSegmentsAsUsed(
             return 0;
           }
 
-          // Validate segmentIds
-          final List<String> invalidSegmentIds = new ArrayList<>();
-          for (String segmentId : segmentIds) {
-            if (SegmentId.iteratePossibleParsingsWithDataSource(dataSourceName, segmentId).isEmpty()) {
-              invalidSegmentIds.add(segmentId);
-            }
-          }
-          if (!invalidSegmentIds.isEmpty()) {
-            throw InvalidInput.exception("Could not parse invalid segment IDs[%s]", invalidSegmentIds);
-          }
-
-          return segmentsMetadataManager.markAsUsedNonOvershadowedSegments(dataSourceName, segmentIds);
+          return segmentsMetadataManager.markAsUsedNonOvershadowedSegments(
+              dataSourceName,
+              IdUtils.getValidSegmentIds(dataSourceName, segmentIds)
+          );
         }
       };
 
@@ -188,7 +183,8 @@ public Response markSegmentsAsUnused(
         final List<String> versions = payload.getVersions();
         final int numUpdatedSegments;
         if (interval != null) {
-          numUpdatedSegments = segmentsMetadataManager.markAsUnusedSegmentsInInterval(dataSourceName, interval, versions);
+          numUpdatedSegments = metadataStorageCoordinator
+              .markSegmentsWithinIntervalAsUnused(dataSourceName, interval, versions);
         } else {
           final Set<SegmentId> segmentIds = payload.getSegmentIds()
                                                    .stream()
@@ -197,7 +193,8 @@ public Response markSegmentsAsUnused(
                                                    .collect(Collectors.toSet());
 
           // Filter out segmentIds that do not belong to this datasource
-          numUpdatedSegments = segmentsMetadataManager.markSegmentsAsUnused(
+          numUpdatedSegments = metadataStorageCoordinator.markSegmentsAsUnused(
+              dataSourceName,
               segmentIds.stream()
                   .filter(segmentId -> segmentId.getDataSource().equals(dataSourceName))
                   .collect(Collectors.toSet())
@@ -240,7 +237,7 @@ public Response markSegmentAsUnused(
     }
 
     SegmentUpdateOperation operation =
-        () -> segmentsMetadataManager.markSegmentAsUnused(segmentId) ? 1 : 0;
+        () -> metadataStorageCoordinator.markSegmentAsUnused(segmentId) ? 1 : 0;
     return performSegmentUpdate(dataSourceName, operation);
   }
 
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentAllocateActionTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentAllocateActionTest.java
index af6406d4c8df..be5f6c3ab399 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentAllocateActionTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentAllocateActionTest.java
@@ -1168,7 +1168,7 @@ public void testSegmentIdMustNotBeReused()
     coordinator.deletePendingSegmentsForTaskAllocatorId(task1.getDataSource(), task1.getTaskAllocatorId());
 
     // Drop all segments
-    coordinator.markSegmentsAsUnusedWithinInterval(task0.getDataSource(), Intervals.ETERNITY);
+    coordinator.markSegmentsWithinIntervalAsUnused(task0.getDataSource(), Intervals.ETERNITY, null);
 
     // Allocate another id and ensure that it doesn't exist in the druid_segments table
     final SegmentIdWithShardSpec theId =
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/common/task/KillUnusedSegmentsTaskTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/common/task/KillUnusedSegmentsTaskTest.java
index 7360fd273b14..052c1ae0a202 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/common/task/KillUnusedSegmentsTaskTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/common/task/KillUnusedSegmentsTaskTest.java
@@ -40,6 +40,7 @@
 import org.apache.druid.server.coordination.BroadcastDatasourceLoadingSpec;
 import org.apache.druid.server.lookup.cache.LookupLoadingSpec;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.assertj.core.api.Assertions;
 import org.easymock.Capture;
 import org.easymock.EasyMock;
@@ -62,7 +63,7 @@
 @RunWith(Parameterized.class)
 public class KillUnusedSegmentsTaskTest extends IngestionTestBase
 {
-  private static final String DATA_SOURCE = "dataSource";
+  private static final String DATA_SOURCE = "wiki";
 
   private TestTaskRunner taskRunner;
 
@@ -147,14 +148,15 @@ public void testKill() throws Exception
   @Test
   public void testKillSegmentsDeleteUnreferencedSiblings() throws Exception
   {
+    final SegmentId nonExistentParent = segment3.getId();
     final Map<String, String> upgradeSegmentMapping = ImmutableMap.of(
         segment1.getId().toString(),
-        "nonExistentParent",
+        nonExistentParent.toString(),
         segment2.getId().toString(),
-        "nonExistentParent"
+        nonExistentParent.toString()
     );
     insertUsedSegments(ImmutableSet.of(segment1, segment2), upgradeSegmentMapping);
-    getStorageCoordinator().markSegmentsAsUnusedWithinInterval(DATA_SOURCE, Intervals.ETERNITY);
+    getStorageCoordinator().markSegmentsWithinIntervalAsUnused(DATA_SOURCE, Intervals.ETERNITY, null);
 
 
     final KillUnusedSegmentsTask task = new KillUnusedSegmentsTaskBuilder()
@@ -185,14 +187,15 @@ public void testKillSegmentsDeleteUnreferencedSiblings() throws Exception
   @Test
   public void testKillSegmentsDoNotDeleteReferencedSibling() throws Exception
   {
+    final SegmentId nonExistentParent = segment3.getId();
     final Map<String, String> upgradeSegmentMapping = ImmutableMap.of(
         segment1.getId().toString(),
-        "nonExistentParent",
+        nonExistentParent.toString(),
         segment2.getId().toString(),
-        "nonExistentParent"
+        nonExistentParent.toString()
     );
     insertUsedSegments(ImmutableSet.of(segment1, segment2), upgradeSegmentMapping);
-    getStorageCoordinator().markSegmentsAsUnusedWithinInterval(DATA_SOURCE, Intervals.ETERNITY);
+    getStorageCoordinator().markSegmentsWithinIntervalAsUnused(DATA_SOURCE, Intervals.ETERNITY, null);
 
 
     final KillUnusedSegmentsTask task = new KillUnusedSegmentsTaskBuilder()
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLifecycleTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLifecycleTest.java
index e0a88f500b82..e6535fdadc90 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLifecycleTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLifecycleTest.java
@@ -817,7 +817,8 @@ public DataSegment apply(String input)
         }
     );
 
-    mdc.setUnusedSegments(expectedUnusedSegments);
+    mdc.commitSegments(Set.copyOf(expectedUnusedSegments), null);
+    expectedUnusedSegments.forEach(segment -> mdc.markSegmentAsUnused(segment.getId()));
 
     // manually create local segments files
     List<File> segmentFiles = new ArrayList<>();
@@ -849,7 +850,7 @@ public DataSegment apply(String input)
     final TaskStatus status = runTask(killUnusedSegmentsTask);
     Assert.assertEquals(taskLocation, status.getLocation());
     Assert.assertEquals("merged statusCode", TaskState.SUCCESS, status.getStatusCode());
-    Assert.assertEquals("num segments published", 0, mdc.getPublished().size());
+    Assert.assertEquals("num segments published", 3, mdc.getPublished().size());
     Assert.assertEquals("num segments nuked", 3, mdc.getNuked().size());
     Assert.assertEquals("delete segment batch call count", 2, mdc.getDeleteSegmentsCount());
     Assert.assertTrue(
@@ -914,7 +915,8 @@ public DataSegment apply(String input)
         }
     );
 
-    mdc.setUnusedSegments(expectedUnusedSegments);
+    mdc.commitSegments(Set.copyOf(expectedUnusedSegments), null);
+    expectedUnusedSegments.forEach(segment -> mdc.markSegmentAsUnused(segment.getId()));
 
     // manually create local segments files
     List<File> segmentFiles = new ArrayList<>();
@@ -947,7 +949,7 @@ public DataSegment apply(String input)
     final TaskStatus status = runTask(killUnusedSegmentsTask);
     Assert.assertEquals(taskLocation, status.getLocation());
     Assert.assertEquals("merged statusCode", TaskState.SUCCESS, status.getStatusCode());
-    Assert.assertEquals("num segments published", 0, mdc.getPublished().size());
+    Assert.assertEquals("num segments published", 3, mdc.getPublished().size());
     Assert.assertEquals("num segments nuked", maxSegmentsToKill, mdc.getNuked().size());
     Assert.assertTrue(
         "expected unused segments get killed",
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordDataSourcesResourceTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordDataSourcesResourceTest.java
index 7bea4b2aec1b..fa4a3f6c51be 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordDataSourcesResourceTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordDataSourcesResourceTest.java
@@ -19,10 +19,10 @@
 
 package org.apache.druid.indexing.overlord.http;
 
-import com.google.common.collect.ImmutableSet;
 import org.apache.druid.audit.AuditManager;
 import org.apache.druid.client.ImmutableDruidDataSource;
 import org.apache.druid.indexing.overlord.TaskMaster;
+import org.apache.druid.indexing.test.TestIndexerMetadataStorageCoordinator;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.granularity.Granularities;
 import org.apache.druid.rpc.indexing.SegmentUpdateResponse;
@@ -63,17 +63,21 @@ public class OverlordDataSourcesResourceTest
   public void setup()
   {
     AuditManager auditManager = EasyMock.createStrictMock(AuditManager.class);
-    segmentsMetadataManager = new TestSegmentsMetadataManager();
+    final TestIndexerMetadataStorageCoordinator metadataStorageCoordinator
+        = new TestIndexerMetadataStorageCoordinator();
+    segmentsMetadataManager = metadataStorageCoordinator.getSegmentsMetadataManager();
 
     TaskMaster taskMaster = new TaskMaster(null, null);
     dataSourcesResource = new OverlordDataSourcesResource(
         taskMaster,
         segmentsMetadataManager,
+        metadataStorageCoordinator,
         auditManager
     );
     taskMaster.becomeFullLeader();
 
     WIKI_SEGMENTS_10X1D.forEach(segmentsMetadataManager::addSegment);
+    metadataStorageCoordinator.commitSegments(Set.copyOf(WIKI_SEGMENTS_10X1D), null);
   }
 
   @Test
@@ -113,7 +117,7 @@ public void testMarkAllSegmentsAsUnused()
   @Test
   public void testMarkSegmentsAsUnused_bySegmentIds()
   {
-    final Set<String> segmentIdsToUpdate = ImmutableSet.of(
+    final Set<String> segmentIdsToUpdate = Set.of(
         WIKI_SEGMENTS_10X1D.get(0).getId().toString(),
         WIKI_SEGMENTS_10X1D.get(8).getId().toString()
     );
@@ -279,7 +283,7 @@ public void testMarkNonOvershadowedSegmentsAsUsed_bySegmentIds()
   {
     dataSourcesResource.markAllSegmentsAsUnused(TestDataSource.WIKI, createHttpServletRequest());
 
-    final Set<String> segmentIdsToUpdate = ImmutableSet.of(
+    final Set<String> segmentIdsToUpdate = Set.of(
         WIKI_SEGMENTS_10X1D.get(0).getId().toString(),
         WIKI_SEGMENTS_10X1D.get(1).getId().toString()
     );
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/test/TestIndexerMetadataStorageCoordinator.java b/indexing-service/src/test/java/org/apache/druid/indexing/test/TestIndexerMetadataStorageCoordinator.java
index 44008c0fb8aa..c7c2bb5ad892 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/test/TestIndexerMetadataStorageCoordinator.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/test/TestIndexerMetadataStorageCoordinator.java
@@ -20,8 +20,6 @@
 package org.apache.druid.indexing.test;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;
 import org.apache.druid.indexing.overlord.DataSourceMetadata;
 import org.apache.druid.indexing.overlord.IndexerMetadataStorageCoordinator;
@@ -34,30 +32,31 @@
 import org.apache.druid.metadata.ReplaceTaskLock;
 import org.apache.druid.segment.SegmentSchemaMapping;
 import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
+import org.apache.druid.server.coordinator.simulate.TestSegmentsMetadataManager;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.SegmentTimeline;
 import org.joda.time.DateTime;
 import org.joda.time.Interval;
 
 import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 public class TestIndexerMetadataStorageCoordinator implements IndexerMetadataStorageCoordinator
 {
   private final ObjectMapper objectMapper = new DefaultObjectMapper();
-  private final Set<DataSegment> published = Sets.newConcurrentHashSet();
   private final Set<DataSegment> nuked = Sets.newConcurrentHashSet();
-  private final List<DataSegment> unusedSegments;
+  private final TestSegmentsMetadataManager segmentsMetadataManager = new TestSegmentsMetadataManager();
+
   private int deleteSegmentsCount = 0;
 
-  public TestIndexerMetadataStorageCoordinator()
+  public TestSegmentsMetadataManager getSegmentsMetadataManager()
   {
-    unusedSegments = new ArrayList<>();
+    return segmentsMetadataManager;
   }
 
   @Override
@@ -87,13 +86,13 @@ public boolean insertDataSourceMetadata(String dataSource, DataSourceMetadata da
   @Override
   public Set<DataSegment> retrieveAllUsedSegments(String dataSource, Segments visibility)
   {
-    return ImmutableSet.of();
+    return Set.of();
   }
 
   @Override
   public List<Pair<DataSegment, String>> retrieveUsedSegmentsAndCreatedDates(String dataSource, List<Interval> intervals)
   {
-    return ImmutableList.of();
+    return List.of();
   }
 
   @Override
@@ -103,7 +102,7 @@ public Set<DataSegment> retrieveUsedSegmentsForIntervals(
       Segments visibility
   )
   {
-    return ImmutableSet.of();
+    return Set.of();
   }
 
   @Override
@@ -126,26 +125,41 @@ public List<DataSegment> retrieveUnusedSegmentsForInterval(
       @Nullable DateTime maxUsedStatusLastUpdatedTime
   )
   {
-    synchronized (unusedSegments) {
-      return ImmutableList.copyOf(
-          unusedSegments.stream()
-                        .filter(ds -> !nuked.contains(ds))
-                        .limit(limit != null ? limit : Long.MAX_VALUE)
-                        .iterator()
-      );
-    }
+    return segmentsMetadataManager.getAllUnusedSegments()
+                                  .stream()
+                                  .filter(ds -> !nuked.contains(ds))
+                                  .limit(limit != null ? limit : Long.MAX_VALUE)
+                                  .collect(Collectors.toList());
   }
 
   @Override
   public Set<DataSegment> retrieveSegmentsById(String dataSource, Set<String> segmentIds)
   {
-    return Collections.emptySet();
+    return Set.of();
+  }
+
+  @Override
+  public boolean markSegmentAsUnused(SegmentId segmentId)
+  {
+    return segmentsMetadataManager.markSegmentAsUnused(segmentId);
+  }
+
+  @Override
+  public int markSegmentsAsUnused(String dataSource, Set<SegmentId> segmentIds)
+  {
+    return segmentsMetadataManager.markSegmentsAsUnused(segmentIds);
+  }
+
+  @Override
+  public int markAllSegmentsAsUnused(String dataSource)
+  {
+    return segmentsMetadataManager.markAsUnusedAllSegmentsInDataSource(dataSource);
   }
 
   @Override
-  public int markSegmentsAsUnusedWithinInterval(String dataSource, Interval interval)
+  public int markSegmentsWithinIntervalAsUnused(String dataSource, Interval interval, @Nullable List<String> versions)
   {
-    return 0;
+    return segmentsMetadataManager.markAsUnusedSegmentsInInterval(dataSource, interval, versions);
   }
 
   @Override
@@ -156,11 +170,11 @@ public Set<DataSegment> commitSegments(
   {
     Set<DataSegment> added = new HashSet<>();
     for (final DataSegment segment : segments) {
-      if (published.add(segment)) {
+      if (segmentsMetadataManager.addSegment(segment)) {
         added.add(segment);
       }
     }
-    return ImmutableSet.copyOf(added);
+    return Set.copyOf(added);
   }
 
   @Override
@@ -172,7 +186,7 @@ public Map<SegmentCreateRequest, SegmentIdWithShardSpec> allocatePendingSegments
       boolean isTimeChunk
   )
   {
-    return Collections.emptyMap();
+    return Map.of();
   }
 
   @Override
@@ -315,7 +329,7 @@ public Map<String, String> retrieveUpgradedFromSegmentIds(
       final Set<String> segmentIds
   )
   {
-    return Collections.emptyMap();
+    return Map.of();
   }
 
   @Override
@@ -324,7 +338,7 @@ public Map<String, Set<String>> retrieveUpgradedToSegmentIds(
       final Set<String> segmentIds
   )
   {
-    return Collections.emptyMap();
+    return Map.of();
   }
 
   @Override
@@ -336,31 +350,23 @@ public SegmentTimeline getSegmentTimelineForAllocation(
   {
     return SegmentTimeline.forSegments(retrieveUsedSegmentsForIntervals(
         dataSource,
-        Collections.singletonList(interval),
+        List.of(interval),
         Segments.INCLUDING_OVERSHADOWED
     ));
   }
 
   public Set<DataSegment> getPublished()
   {
-    return ImmutableSet.copyOf(published);
+    return segmentsMetadataManager.getAllSegments();
   }
 
   public Set<DataSegment> getNuked()
   {
-    return ImmutableSet.copyOf(nuked);
+    return Set.copyOf(nuked);
   }
 
   public int getDeleteSegmentsCount()
   {
     return deleteSegmentsCount;
   }
-
-  public void setUnusedSegments(List<DataSegment> newUnusedSegments)
-  {
-    synchronized (unusedSegments) {
-      unusedSegments.clear();
-      unusedSegments.addAll(newUnusedSegments);
-    }
-  }
 }
diff --git a/processing/src/main/java/org/apache/druid/common/utils/IdUtils.java b/processing/src/main/java/org/apache/druid/common/utils/IdUtils.java
index 0544439da028..de400141f0ac 100644
--- a/processing/src/main/java/org/apache/druid/common/utils/IdUtils.java
+++ b/processing/src/main/java/org/apache/druid/common/utils/IdUtils.java
@@ -31,7 +31,9 @@
 
 import javax.annotation.Nullable;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -167,4 +169,35 @@ public static SegmentId getValidSegmentId(String dataSource, String serializedSe
       return parsedSegmentId;
     }
   }
+
+  /**
+   * Tries to parse the given serialized IDs as {@link SegmentId}s of the given
+   * datasource.
+   *
+   * @return Set containing valid segment IDs.
+   * @throws DruidException if any of the given segment IDs is invalid
+   */
+  public static Set<SegmentId> getValidSegmentIds(String dataSource, Set<String> serializedIds)
+  {
+    final Set<SegmentId> validSegmentIds = new HashSet<>();
+    final Set<String> invalidIds = new HashSet<>();
+
+    for (String id : serializedIds) {
+      final SegmentId validId = SegmentId.tryParse(dataSource, id);
+      if (validId == null) {
+        invalidIds.add(id);
+      } else {
+        validSegmentIds.add(validId);
+      }
+    }
+
+    if (!invalidIds.isEmpty()) {
+      throw InvalidInput.exception(
+          "Could not parse segment IDs[%s] for datasource[%s]",
+          invalidIds, dataSource
+      );
+    }
+
+    return validSegmentIds;
+  }
 }
diff --git a/server/src/main/java/org/apache/druid/indexing/overlord/IndexerMetadataStorageCoordinator.java b/server/src/main/java/org/apache/druid/indexing/overlord/IndexerMetadataStorageCoordinator.java
index eb2ee13e3aaa..473e462dd518 100644
--- a/server/src/main/java/org/apache/druid/indexing/overlord/IndexerMetadataStorageCoordinator.java
+++ b/server/src/main/java/org/apache/druid/indexing/overlord/IndexerMetadataStorageCoordinator.java
@@ -25,6 +25,7 @@
 import org.apache.druid.segment.SegmentSchemaMapping;
 import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.SegmentTimeline;
 import org.joda.time.DateTime;
 import org.joda.time.Interval;
@@ -148,14 +149,39 @@ List<DataSegment> retrieveUnusedSegmentsForInterval(
   Set<DataSegment> retrieveSegmentsById(String dataSource, Set<String> segmentIds);
 
   /**
-   * Mark as unused segments which include ONLY data within the given interval.
+   * Marks the segment as unused.
    *
-   * @param dataSource The data source the segments belong to
-   * @param interval   Filter the data segments to ones that include data in this interval exclusively.
+   * @return true if the segment was updated, false otherwise
+   */
+  boolean markSegmentAsUnused(SegmentId segmentId);
+
+  /**
+   * Marks the given segments as unused.
+   *
+   * @return Number of segments updated
+   */
+  int markSegmentsAsUnused(String dataSource, Set<SegmentId> segmentIds);
+
+  /**
+   * Marks all the segments in given datasource as unused.
    *
-   * @return number of segments marked unused
+   * @return Number of updated segments
    */
-  int markSegmentsAsUnusedWithinInterval(String dataSource, Interval interval);
+  int markAllSegmentsAsUnused(String dataSource);
+
+  /**
+   * Marks segments that are fully contained in the given interval as unused.
+   *
+   * @param versions Optional list of segment versions eligible for update.
+   *                 If this list is passed as null, all segment versions are
+   *                 eligible for updated. If passed as empty, no segment is updated.
+   * @return Number of segments updated
+   */
+  int markSegmentsWithinIntervalAsUnused(
+      String dataSource,
+      Interval interval,
+      @Nullable List<String> versions
+  );
 
   /**
    * Attempts to insert a set of segments and corresponding schema to the metadata storage.
diff --git a/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java b/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java
index 9a0f91d6afd6..b4682e2be5a3 100644
--- a/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java
+++ b/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java
@@ -235,7 +235,7 @@ public Set<DataSegment> retrieveSegmentsById(String dataSource, Set<String> segm
     return inReadOnlyDatasourceTransaction(
         dataSource,
         transaction ->
-            retrieveSegmentsById(transaction, segmentIds)
+            retrieveSegmentsById(dataSource, transaction, segmentIds)
                 .stream()
                 .map(DataSegmentPlus::getDataSegment)
                 .collect(Collectors.toSet())
@@ -243,18 +243,43 @@ public Set<DataSegment> retrieveSegmentsById(String dataSource, Set<String> segm
   }
 
   @Override
-  public int markSegmentsAsUnusedWithinInterval(String dataSource, Interval interval)
+  public int markSegmentsWithinIntervalAsUnused(
+      String dataSource,
+      Interval interval,
+      @Nullable List<String> versions
+  )
   {
-    final Integer numSegmentsMarkedUnused = inReadWriteDatasourceTransaction(
+    return inReadWriteDatasourceTransaction(
         dataSource,
-        transaction -> transaction.markSegmentsWithinIntervalAsUnused(interval, DateTimes.nowUtc())
+        transaction -> transaction.markSegmentsWithinIntervalAsUnused(interval, versions, DateTimes.nowUtc())
     );
+  }
 
-    log.info(
-        "Marked [%,d] segments unused for datasource[%s], interval[%s].",
-        numSegmentsMarkedUnused, dataSource, interval
+  @Override
+  public boolean markSegmentAsUnused(SegmentId segmentId)
+  {
+    return inReadWriteDatasourceTransaction(
+        segmentId.getDataSource(),
+        transaction -> transaction.markSegmentAsUnused(segmentId, DateTimes.nowUtc())
+    );
+  }
+
+  @Override
+  public int markSegmentsAsUnused(String dataSource, Set<SegmentId> segmentIds)
+  {
+    return inReadWriteDatasourceTransaction(
+        dataSource,
+        transaction -> transaction.markSegmentsAsUnused(segmentIds, DateTimes.nowUtc())
+    );
+  }
+
+  @Override
+  public int markAllSegmentsAsUnused(String dataSource)
+  {
+    return inReadWriteDatasourceTransaction(
+        dataSource,
+        transaction -> transaction.markAllSegmentsAsUnused(DateTimes.nowUtc())
     );
-    return numSegmentsMarkedUnused;
   }
 
   private SegmentTimeline getTimelineForIntervals(
@@ -355,6 +380,7 @@ public SegmentPublishResult commitReplaceSegments(
             final Set<DataSegment> segmentsToInsert = new HashSet<>(replaceSegments);
 
             Set<DataSegmentPlus> upgradedSegments = createNewIdsOfAppendSegmentsAfterReplace(
+                dataSource,
                 transaction,
                 replaceSegments,
                 locksHeldByReplaceTask
@@ -553,7 +579,7 @@ public SegmentIdWithShardSpec allocatePendingSegment(
    * those versions.</li>
    * </ul>
    *
-   * @param replaceSegments Segments being committed by a REPLACE task
+   * @param replaceSegments Segments being committed by a "REPLACE" task
    * @return List of inserted pending segment records
    */
   private List<PendingSegmentRecord> upgradePendingSegmentsOverlappingWith(
@@ -1139,7 +1165,7 @@ private Map<SegmentCreateRequest, PendingSegmentRecord> createNewSegments(
       return Collections.emptyMap();
     }
 
-    // Shard spec of any of the requests (as they are all compatible) can be used to
+    // Shard spec of one of the requests (as they are all compatible) can be used to
     // identify existing shard specs that share partition space with the requested ones.
     final PartialShardSpec partialShardSpec = requests.get(0).getPartialShardSpec();
 
@@ -1465,7 +1491,7 @@ private SegmentIdWithShardSpec getTrueAllocatedId(
   )
   {
     // Check if there is a conflict with an existing entry in the segments table
-    if (transaction.findSegment(allocatedId.asSegmentId()) == null) {
+    if (transaction.findExistingSegmentIds(Set.of(allocatedId.asSegmentId())).isEmpty()) {
       return allocatedId;
     }
 
@@ -1559,7 +1585,8 @@ private Set<DataSegment> insertSegments(
         persistSchema(transaction, segments, segmentSchemaMapping);
       }
 
-      Set<String> existedSegments = transaction.findExistingSegmentIds(segments);
+      final Set<SegmentId> segmentIds = segments.stream().map(DataSegment::getId).collect(Collectors.toSet());
+      Set<String> existedSegments = transaction.findExistingSegmentIds(segmentIds);
       log.info("Found these segments already exist in DB: %s", existedSegments);
 
       for (DataSegment segment : segments) {
@@ -1603,15 +1630,16 @@ private Set<DataSegment> insertSegments(
   }
 
   /**
-   * Creates new versions of segments appended while a REPLACE task was in progress.
+   * Creates new versions of segments appended while a "REPLACE" task was in progress.
    */
   private Set<DataSegmentPlus> createNewIdsOfAppendSegmentsAfterReplace(
+      final String dataSource,
       final SegmentMetadataTransaction transaction,
       final Set<DataSegment> replaceSegments,
       final Set<ReplaceTaskLock> locksHeldByReplaceTask
   )
   {
-    // If a REPLACE task has locked an interval, it would commit some segments
+    // If a "REPLACE" task has locked an interval, it would commit some segments
     // (or at least tombstones) in that interval (except in LEGACY_REPLACE ingestion mode)
     if (replaceSegments.isEmpty() || locksHeldByReplaceTask.isEmpty()) {
       return Collections.emptySet();
@@ -1638,7 +1666,7 @@ private Set<DataSegmentPlus> createNewIdsOfAppendSegmentsAfterReplace(
         = getAppendSegmentsCommittedDuringTask(transaction, taskId);
 
     final List<DataSegmentPlus> segmentsToUpgrade
-        = retrieveSegmentsById(transaction, upgradeSegmentToLockVersion.keySet());
+        = retrieveSegmentsById(dataSource, transaction, upgradeSegmentToLockVersion.keySet());
 
     if (segmentsToUpgrade.isEmpty()) {
       return Collections.emptySet();
@@ -1775,7 +1803,8 @@ private Set<DataSegment> insertSegments(
     }
 
     // Do not insert segment IDs which already exist
-    Set<String> existingSegmentIds = transaction.findExistingSegmentIds(segments);
+    final Set<SegmentId> segmentIds = segments.stream().map(DataSegment::getId).collect(Collectors.toSet());
+    Set<String> existingSegmentIds = transaction.findExistingSegmentIds(segmentIds);
     final Set<DataSegment> segmentsToInsert = segments.stream().filter(
         s -> !existingSegmentIds.contains(s.getId().toString())
     ).collect(Collectors.toSet());
@@ -1896,6 +1925,7 @@ private void insertIntoUpgradeSegmentsTable(
   }
 
   private List<DataSegmentPlus> retrieveSegmentsById(
+      String dataSource,
       SegmentMetadataReadTransaction transaction,
       Set<String> segmentIds
   )
@@ -1904,10 +1934,13 @@ private List<DataSegmentPlus> retrieveSegmentsById(
       return Collections.emptyList();
     }
 
+    // Validate segment IDs
+    final Set<SegmentId> validSegmentIds = IdUtils.getValidSegmentIds(dataSource, segmentIds);
+
     if (schemaPersistEnabled) {
-      return transaction.findSegmentsWithSchema(segmentIds);
+      return transaction.findSegmentsWithSchema(validSegmentIds);
     } else {
-      return transaction.findSegments(segmentIds);
+      return transaction.findSegments(validSegmentIds);
     }
   }
 
@@ -2280,10 +2313,11 @@ Set<DataSegment> retrieveUsedSegmentsForAllocation(
     for (Map<Interval, SegmentId> itvlMap : versionIntervalToSmallestSegmentId.values()) {
       segmentIdsToRetrieve.addAll(itvlMap.values());
     }
-    final List<DataSegment> dataSegments = transaction.findUsedSegments(segmentIdsToRetrieve);
+    final List<DataSegmentPlus> dataSegments = transaction.findUsedSegments(segmentIdsToRetrieve);
     final Set<SegmentId> retrievedIds = new HashSet<>();
     final Map<String, Map<Interval, Integer>> versionIntervalToNumCorePartitions = new HashMap<>();
-    for (DataSegment segment : dataSegments) {
+    for (DataSegmentPlus segmentPlus : dataSegments) {
+      final DataSegment segment = segmentPlus.getDataSegment();
       versionIntervalToNumCorePartitions.computeIfAbsent(segment.getVersion(), v -> new HashMap<>())
                                         .put(segment.getInterval(), segment.getShardSpec().getNumCorePartitions());
       retrievedIds.add(segment.getId());
diff --git a/server/src/main/java/org/apache/druid/metadata/SegmentsMetadataManager.java b/server/src/main/java/org/apache/druid/metadata/SegmentsMetadataManager.java
index 330822067ad4..97a77d5208ab 100644
--- a/server/src/main/java/org/apache/druid/metadata/SegmentsMetadataManager.java
+++ b/server/src/main/java/org/apache/druid/metadata/SegmentsMetadataManager.java
@@ -70,7 +70,7 @@ public interface SegmentsMetadataManager
    *                                               any of the given segment IDs
    *                                               do not exist in the metadata store.
    */
-  int markAsUsedNonOvershadowedSegments(String dataSource, Set<String> segmentIds);
+  int markAsUsedNonOvershadowedSegments(String dataSource, Set<SegmentId> segmentIds);
 
   /**
    * Returns true if the state of the segment entry is changed in the database as the result of this call (that is, the
diff --git a/server/src/main/java/org/apache/druid/metadata/SqlSegmentsMetadataManager.java b/server/src/main/java/org/apache/druid/metadata/SqlSegmentsMetadataManager.java
index 6cf7e21605a4..11b00742bc8e 100644
--- a/server/src/main/java/org/apache/druid/metadata/SqlSegmentsMetadataManager.java
+++ b/server/src/main/java/org/apache/druid/metadata/SqlSegmentsMetadataManager.java
@@ -739,7 +739,7 @@ private int markNonOvershadowedSegmentsAsUsed(
   }
 
   @Override
-  public int markAsUsedNonOvershadowedSegments(final String dataSource, final Set<String> segmentIds)
+  public int markAsUsedNonOvershadowedSegments(final String dataSource, final Set<SegmentId> segmentIds)
   {
     try {
       Pair<List<DataSegment>, SegmentTimeline> unusedSegmentsAndTimeline = connector
@@ -775,7 +775,7 @@ public int markAsUsedNonOvershadowedSegments(final String dataSource, final Set<
 
   private List<DataSegment> retrieveUnusedSegments(
       final String dataSource,
-      final Set<String> segmentIds,
+      final Set<SegmentId> segmentIds,
       final Handle handle
   )
   {
@@ -783,11 +783,11 @@ private List<DataSegment> retrieveUnusedSegments(
         .forHandle(handle, connector, dbTables.get(), jsonMapper)
         .retrieveSegmentsById(dataSource, segmentIds);
 
-    final Set<String> unknownSegmentIds = new HashSet<>(segmentIds);
+    final Set<SegmentId> unknownSegmentIds = new HashSet<>(segmentIds);
     final List<DataSegment> unusedSegments = new ArrayList<>();
     for (DataSegmentPlus entry : retrievedSegments) {
       final DataSegment segment = entry.getDataSegment();
-      unknownSegmentIds.remove(segment.getId().toString());
+      unknownSegmentIds.remove(segment.getId());
       if (Boolean.FALSE.equals(entry.getUsed())) {
         unusedSegments.add(segment);
       }
@@ -823,7 +823,7 @@ private int markSegmentsAsUsed(final List<SegmentId> segmentIds)
     return connector.getDBI().withHandle(
         handle ->
             SqlSegmentsMetadataQuery.forHandle(handle, connector, dbTables.get(), jsonMapper)
-                                    .markSegments(segmentIds, true)
+                                    .markSegments(segmentIds, true, DateTimes.nowUtc())
     );
   }
 
@@ -854,7 +854,7 @@ public boolean markSegmentAsUnused(final SegmentId segmentId)
       final int numSegments = connector.getDBI().withHandle(
           handle ->
               SqlSegmentsMetadataQuery.forHandle(handle, connector, dbTables.get(), jsonMapper)
-                                      .markSegments(Collections.singletonList(segmentId), false)
+                                      .markSegments(List.of(segmentId), false, DateTimes.nowUtc())
       );
 
       return numSegments > 0;
@@ -871,7 +871,7 @@ public int markSegmentsAsUnused(Set<SegmentId> segmentIds)
     return connector.getDBI().withHandle(
         handle ->
             SqlSegmentsMetadataQuery.forHandle(handle, connector, dbTables.get(), jsonMapper)
-                                    .markSegments(segmentIds, false)
+                                    .markSegments(segmentIds, false, DateTimes.nowUtc())
     );
   }
 
diff --git a/server/src/main/java/org/apache/druid/metadata/SqlSegmentsMetadataQuery.java b/server/src/main/java/org/apache/druid/metadata/SqlSegmentsMetadataQuery.java
index d683be585753..6a6d9ac64fa8 100644
--- a/server/src/main/java/org/apache/druid/metadata/SqlSegmentsMetadataQuery.java
+++ b/server/src/main/java/org/apache/druid/metadata/SqlSegmentsMetadataQuery.java
@@ -383,7 +383,7 @@ public Set<SegmentId> retrieveUsedSegmentIds(
    */
   public List<DataSegmentPlus> retrieveSegmentsById(
       String datasource,
-      Set<String> segmentIds
+      Set<SegmentId> segmentIds
   )
   {
     try (CloseableIterator<DataSegmentPlus> iterator
@@ -406,11 +406,12 @@ public List<DataSegmentPlus> retrieveSegmentsById(
    */
   public CloseableIterator<DataSegmentPlus> retrieveSegmentsByIdIterator(
       final String datasource,
-      final Set<String> segmentIds,
+      final Set<SegmentId> segmentIds,
       final boolean includeSchemaInfo
   )
   {
-    final List<List<String>> partitionedSegmentIds = Lists.partition(List.copyOf(segmentIds), 100);
+    final List<String> ids = segmentIds.stream().map(SegmentId::toString).collect(Collectors.toList());
+    final List<List<String>> partitionedSegmentIds = Lists.partition(ids, 100);
 
     // CloseableIterator to query segments in batches
     return new CloseableIterator<>()
@@ -467,7 +468,7 @@ public DataSegmentPlus next()
    */
   public List<DataSegmentPlus> retrieveSegmentsWithSchemaById(
       String datasource,
-      Set<String> segmentIds
+      Set<SegmentId> segmentIds
   )
   {
     try (CloseableIterator<DataSegmentPlus> iterator
@@ -524,7 +525,7 @@ private CloseableIterator<DataSegmentPlus> retrieveSegmentBatchById(
     } else {
       final Query<Map<String, Object>> query = handle.createQuery(
           StringUtils.format(
-              "SELECT payload, used, upgraded_from_segment_id, used_status_last_updated"
+              "SELECT payload, used, upgraded_from_segment_id, used_status_last_updated, created_date"
               + " FROM %s WHERE dataSource = :dataSource %s",
               dbTables.getSegmentsTable(), getParameterizedInConditionForColumn("id", segmentIds)
           )
@@ -538,7 +539,7 @@ private CloseableIterator<DataSegmentPlus> retrieveSegmentBatchById(
           .map(
               (index, r, ctx) -> new DataSegmentPlus(
                   JacksonUtils.readValue(jsonMapper, r.getBytes(1), DataSegment.class),
-                  null,
+                  DateTimes.of(r.getString(5)),
                   DateTimes.of(r.getString(4)),
                   r.getBoolean(2),
                   null,
@@ -561,7 +562,7 @@ private CloseableIterator<DataSegmentPlus> retrieveSegmentBatchById(
    *
    * @return the number of segments actually modified.
    */
-  public int markSegments(final Collection<SegmentId> segmentIds, final boolean used)
+  public int markSegments(final Collection<SegmentId> segmentIds, final boolean used, DateTime updateTime)
   {
     final String dataSource;
 
@@ -583,7 +584,7 @@ public int markSegments(final Collection<SegmentId> segmentIds, final boolean us
         );
 
     for (SegmentId segmentId : segmentIds) {
-      batch.add(used, DateTimes.nowUtc().toString(), dataSource, segmentId.toString());
+      batch.add(used, updateTime.toString(), dataSource, segmentId.toString());
     }
 
     final int[] segmentChanges = batch.execute();
@@ -705,52 +706,42 @@ public int markSegmentsUnused(
               DataSegment::getId
           )
       );
-      return markSegments(segments, false);
+      return markSegments(segments, false, updateTime);
     }
   }
 
   /**
    * Retrieve the used segment for a given id if it exists in the metadata store and null otherwise
    */
-  public DataSegment retrieveUsedSegmentForId(String id)
+  @Nullable
+  public DataSegment retrieveUsedSegmentForId(SegmentId segmentId)
   {
     final String query = "SELECT payload FROM %s WHERE used = true AND id = :id";
 
-    final Query<Map<String, Object>> sql = handle
+    final List<DataSegment> segments = handle
         .createQuery(StringUtils.format(query, dbTables.getSegmentsTable()))
-        .bind("id", id);
-
-    final ResultIterator<DataSegment> resultIterator =
-        sql.map((index, r, ctx) -> JacksonUtils.readValue(jsonMapper, r.getBytes(1), DataSegment.class))
-           .iterator();
-
-    if (resultIterator.hasNext()) {
-      return resultIterator.next();
-    }
+        .bind("id", segmentId.toString())
+        .map((index, r, ctx) -> JacksonUtils.readValue(jsonMapper, r.getBytes(1), DataSegment.class))
+        .list();
 
-    return null;
+    return segments.isEmpty() ? null : segments.get(0);
   }
 
   /**
    * Retrieve the segment for a given id if it exists in the metadata store and null otherwise
    */
-  public DataSegment retrieveSegmentForId(String id)
+  @Nullable
+  public DataSegment retrieveSegmentForId(SegmentId segmentId)
   {
     final String query = "SELECT payload FROM %s WHERE id = :id";
 
-    final Query<Map<String, Object>> sql = handle
+    final List<DataSegment> segments = handle
         .createQuery(StringUtils.format(query, dbTables.getSegmentsTable()))
-        .bind("id", id);
-
-    final ResultIterator<DataSegment> resultIterator =
-        sql.map((index, r, ctx) -> JacksonUtils.readValue(jsonMapper, r.getBytes(1), DataSegment.class))
-           .iterator();
-
-    if (resultIterator.hasNext()) {
-      return resultIterator.next();
-    }
+        .bind("id", segmentId.toString())
+        .map((index, r, ctx) -> JacksonUtils.readValue(jsonMapper, r.getBytes(1), DataSegment.class))
+        .list();
 
-    return null;
+    return segments.isEmpty() ? null : segments.get(0);
   }
 
   public List<SegmentIdWithShardSpec> retrievePendingSegmentIds(
@@ -1143,7 +1134,7 @@ private UnmodifiableIterator<DataSegmentPlus> retrieveSegmentsPlusInIntervalsBat
         true
     );
 
-    final ResultIterator<DataSegmentPlus> resultIterator = getDataSegmentPlusResultIterator(sql);
+    final ResultIterator<DataSegmentPlus> resultIterator = getDataSegmentPlusResultIterator(sql, used);
 
     return filterDataSegmentPlusIteratorByInterval(resultIterator, intervals, matchMode);
   }
@@ -1165,9 +1156,9 @@ private Query<Map<String, Object>> buildSegmentsTableQuery(
     final boolean compareAsString = intervals.stream().allMatch(Intervals::canCompareEndpointsAsStrings);
     final StringBuilder sb = new StringBuilder();
     if (includeExtraInfo) {
-      sb.append("SELECT payload, created_date, used_status_last_updated FROM %s WHERE used = :used AND dataSource = :dataSource");
+      sb.append("SELECT id, payload, created_date, used_status_last_updated FROM %s WHERE used = :used AND dataSource = :dataSource");
     } else {
-      sb.append("SELECT payload FROM %s WHERE used = :used AND dataSource = :dataSource");
+      sb.append("SELECT id, payload FROM %s WHERE used = :used AND dataSource = :dataSource");
     }
 
     if (compareAsString) {
@@ -1234,22 +1225,33 @@ private Query<Map<String, Object>> buildSegmentsTableQuery(
 
   private ResultIterator<DataSegment> getDataSegmentResultIterator(Query<Map<String, Object>> sql)
   {
-    return sql.map((index, r, ctx) -> JacksonUtils.readValue(jsonMapper, r.getBytes(1), DataSegment.class))
-        .iterator();
+    return sql.map((index, r, ctx) -> JacksonUtils.readValue(jsonMapper, r.getBytes(2), DataSegment.class))
+              .iterator();
   }
 
-  private ResultIterator<DataSegmentPlus> getDataSegmentPlusResultIterator(Query<Map<String, Object>> sql)
+  private ResultIterator<DataSegmentPlus> getDataSegmentPlusResultIterator(
+      Query<Map<String, Object>> sql,
+      boolean used
+  )
   {
-    return sql.map((index, r, ctx) -> new DataSegmentPlus(
-            JacksonUtils.readValue(jsonMapper, r.getBytes(1), DataSegment.class),
-            DateTimes.of(r.getString(2)),
+    return sql.map((index, r, ctx) -> {
+      final String segmentId = r.getString(1);
+      try {
+        return new DataSegmentPlus(
+            JacksonUtils.readValue(jsonMapper, r.getBytes(2), DataSegment.class),
             DateTimes.of(r.getString(3)),
-            null,
+            DateTimes.of(r.getString(4)),
+            used,
             null,
             null,
             null
-        ))
-        .iterator();
+        );
+      }
+      catch (Throwable t) {
+        log.error(t, "Could not read segment with ID[%s]", segmentId);
+        return null;
+      }
+    }).iterator();
   }
 
   private UnmodifiableIterator<DataSegment> filterDataSegmentIteratorByInterval(
@@ -1288,7 +1290,9 @@ private UnmodifiableIterator<DataSegmentPlus> filterDataSegmentPlusIteratorByInt
     return Iterators.filter(
         resultIterator,
         dataSegment -> {
-          if (intervals.isEmpty()) {
+          if (dataSegment == null) {
+            return false;
+          } else if (intervals.isEmpty()) {
             return true;
           } else {
             // Must re-check that the interval matches, even if comparing as string, because the *segment interval*
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/CachedSegmentMetadataTransaction.java b/server/src/main/java/org/apache/druid/metadata/segment/CachedSegmentMetadataTransaction.java
index da00d2918832..b6f21b301f09 100644
--- a/server/src/main/java/org/apache/druid/metadata/segment/CachedSegmentMetadataTransaction.java
+++ b/server/src/main/java/org/apache/druid/metadata/segment/CachedSegmentMetadataTransaction.java
@@ -33,10 +33,12 @@
 
 import javax.annotation.Nullable;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.function.Consumer;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 
 /**
  * A {@link SegmentMetadataTransaction} that reads only from the cache and sends
@@ -140,9 +142,25 @@ public void close()
   // READ METHODS
 
   @Override
-  public Set<String> findExistingSegmentIds(Set<DataSegment> segments)
+  public Set<String> findExistingSegmentIds(Set<SegmentId> segmentIds)
   {
-    return metadataCache.findExistingSegmentIds(segments);
+    final Set<SegmentId> remainingIdsToFind = new HashSet<>(segmentIds);
+
+    // Try to find IDs in cache
+    final Set<String> foundIds = metadataCache.findUsedSegments(remainingIdsToFind)
+                                              .stream()
+                                              .map(segment -> segment.getDataSegment().getId().toString())
+                                              .collect(Collectors.toCollection(HashSet::new));
+    remainingIdsToFind.removeIf(id -> foundIds.contains(id.toString()));
+
+    // Find remaining IDs in metadata store
+    if (!remainingIdsToFind.isEmpty()) {
+      foundIds.addAll(
+          delegate.findExistingSegmentIds(remainingIdsToFind)
+      );
+    }
+
+    return Set.copyOf(foundIds);
   }
 
   @Override
@@ -154,20 +172,33 @@ public Set<SegmentId> findUsedSegmentIdsOverlapping(Interval interval)
   @Override
   public SegmentId findHighestUnusedSegmentId(Interval interval, String version)
   {
-    return metadataCache.findHighestUnusedSegmentId(interval, version);
+    // Read from metadata store since unused segments are not cached
+    return delegate.findHighestUnusedSegmentId(interval, version);
   }
 
   @Override
-  public List<DataSegmentPlus> findSegments(Set<String> segmentIds)
+  public List<DataSegmentPlus> findSegments(Set<SegmentId> segmentIds)
   {
-    // Read from metadata store since unused segment payloads are not cached
-    return delegate.findSegments(segmentIds);
+    final Set<SegmentId> remainingIdsToFind = new HashSet<>(segmentIds);
+
+    // Try to find segments in cache
+    final List<DataSegmentPlus> foundSegments = new ArrayList<>(
+        metadataCache.findUsedSegments(remainingIdsToFind)
+    );
+    foundSegments.forEach(segment -> remainingIdsToFind.remove(segment.getDataSegment().getId()));
+
+    // Find remaining segments in metadata store
+    foundSegments.addAll(
+        delegate.findSegments(remainingIdsToFind)
+    );
+
+    return List.copyOf(foundSegments);
   }
 
   @Override
-  public List<DataSegmentPlus> findSegmentsWithSchema(Set<String> segmentIds)
+  public List<DataSegmentPlus> findSegmentsWithSchema(Set<SegmentId> segmentIds)
   {
-    // Read from metadata store since unused segment payloads are not cached
+    // Read from metadata store since unused segment payloads and schema info is not cached
     return delegate.findSegmentsWithSchema(segmentIds);
   }
 
@@ -178,7 +209,7 @@ public Set<DataSegment> findUsedSegmentsOverlappingAnyOf(List<Interval> interval
   }
 
   @Override
-  public List<DataSegment> findUsedSegments(Set<SegmentId> segmentIds)
+  public List<DataSegmentPlus> findUsedSegments(Set<SegmentId> segmentIds)
   {
     return metadataCache.findUsedSegments(segmentIds);
   }
@@ -204,8 +235,14 @@ public List<DataSegment> findUnusedSegments(
   @Override
   public DataSegment findSegment(SegmentId segmentId)
   {
-    // Read from metadata store since unused segment payloads are not cached
-    return delegate.findSegment(segmentId);
+    // Try to find used segment in cache
+    final DataSegment usedSegment = metadataCache.findUsedSegment(segmentId);
+    if (usedSegment == null) {
+      // Read from metadata store since unused segment payloads are not cached
+      return delegate.findSegment(segmentId);
+    } else {
+      return usedSegment;
+    }
   }
 
   @Override
@@ -265,10 +302,38 @@ public int insertSegmentsWithMetadata(Set<DataSegmentPlus> segments)
   }
 
   @Override
-  public int markSegmentsWithinIntervalAsUnused(Interval interval, DateTime updateTime)
+  public boolean markSegmentAsUnused(SegmentId segmentId, DateTime updateTime)
+  {
+    return performWriteAction(
+        writer -> writer.markSegmentAsUnused(segmentId, updateTime)
+    );
+  }
+
+  @Override
+  public int markSegmentsAsUnused(Set<SegmentId> segmentIds, DateTime updateTime)
+  {
+    return performWriteAction(
+        writer -> writer.markSegmentsAsUnused(segmentIds, updateTime)
+    );
+  }
+
+  @Override
+  public int markAllSegmentsAsUnused(DateTime updateTime)
+  {
+    return performWriteAction(
+        writer -> writer.markAllSegmentsAsUnused(updateTime)
+    );
+  }
+
+  @Override
+  public int markSegmentsWithinIntervalAsUnused(
+      Interval interval,
+      @Nullable List<String> versions,
+      DateTime updateTime
+  )
   {
     return performWriteAction(
-        writer -> writer.markSegmentsWithinIntervalAsUnused(interval, updateTime)
+        writer -> writer.markSegmentsWithinIntervalAsUnused(interval, versions, updateTime)
     );
   }
 
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/DatasourceSegmentMetadataReader.java b/server/src/main/java/org/apache/druid/metadata/segment/DatasourceSegmentMetadataReader.java
index 6b5db8b9e898..612c6bf2ce34 100644
--- a/server/src/main/java/org/apache/druid/metadata/segment/DatasourceSegmentMetadataReader.java
+++ b/server/src/main/java/org/apache/druid/metadata/segment/DatasourceSegmentMetadataReader.java
@@ -40,7 +40,7 @@ public interface DatasourceSegmentMetadataReader
    * Retrieves the IDs of segments (out of the given set) which already exist in
    * the metadata store.
    */
-  Set<String> findExistingSegmentIds(Set<DataSegment> segments);
+  Set<String> findExistingSegmentIds(Set<SegmentId> segments);
 
   /**
    * Retrieves IDs of used segments that belong to the datasource and overlap
@@ -68,7 +68,7 @@ Set<DataSegment> findUsedSegmentsOverlappingAnyOf(
   /**
    * Retrieves used segments for the given segment IDs.
    */
-  List<DataSegment> findUsedSegments(Set<SegmentId> segmentIds);
+  List<DataSegmentPlus> findUsedSegments(Set<SegmentId> segmentIds);
 
   /**
    * Retrieves used segments that overlap with any of the given intervals. If the
@@ -98,7 +98,7 @@ Set<DataSegmentPlus> findUsedSegmentsPlusOverlappingAnyOf(
    * Retrieves segments for the given segment IDs.
    */
   List<DataSegmentPlus> findSegments(
-      Set<String> segmentIds
+      Set<SegmentId> segmentIds
   );
 
   /**
@@ -106,7 +106,7 @@ List<DataSegmentPlus> findSegments(
    * schema fingerprint for the given segment IDs.
    */
   List<DataSegmentPlus> findSegmentsWithSchema(
-      Set<String> segmentIds
+      Set<SegmentId> segmentIds
   );
 
   /**
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/DatasourceSegmentMetadataWriter.java b/server/src/main/java/org/apache/druid/metadata/segment/DatasourceSegmentMetadataWriter.java
index 418c8a762fd4..25b275998e4b 100644
--- a/server/src/main/java/org/apache/druid/metadata/segment/DatasourceSegmentMetadataWriter.java
+++ b/server/src/main/java/org/apache/druid/metadata/segment/DatasourceSegmentMetadataWriter.java
@@ -26,6 +26,7 @@
 import org.joda.time.DateTime;
 import org.joda.time.Interval;
 
+import javax.annotation.Nullable;
 import java.util.List;
 import java.util.Set;
 
@@ -50,18 +51,52 @@ public interface DatasourceSegmentMetadataWriter
   int insertSegmentsWithMetadata(Set<DataSegmentPlus> segments);
 
   /**
-   * Marks the segments fully contained in the given interval as unused.
+   * Marks the segment as unused.
+   *
+   * @param updateTime The last updated timestamp of the segment will be set to
+   *                   this value if updated successfully.
+   * @return true if the segment was updated successfully, false otherwise
+   */
+  boolean markSegmentAsUnused(SegmentId segmentId, DateTime updateTime);
+
+  /**
+   * Marks the given segments as unused.
+   *
+   * @param updateTime Updated segments will have their last updated timestamp
+   *                   set to this value.
+   * @return Number of segments updated successfully
+   */
+  int markSegmentsAsUnused(Set<SegmentId> segmentIds, DateTime updateTime);
+
+  /**
+   * Marks all the segments in given datasource as unused.
+   *
+   * @param updateTime Updated segments will have their last updated timestamp
+   *                   set to this value.
+   * @return Number of segments successfully
+   */
+  int markAllSegmentsAsUnused(DateTime updateTime);
+
+  /**
+   * Marks segments that are fully contained in the given interval as unused.
    *
    * @param interval   Only segments fully contained within this interval are
    *                   eligible to be marked as unused.
+   * @param versions   Optional set of segment versions eligible for update.
+   *                   If this set is passed as null, all segment versions are
+   *                   eligible for update. If passed as empty, no segment is updated.
    * @param updateTime Updated segments will have their last updated timestamp
    *                   set to this value.
    * @return Number of segments updated successfully
    */
-  int markSegmentsWithinIntervalAsUnused(Interval interval, DateTime updateTime);
+  int markSegmentsWithinIntervalAsUnused(
+      Interval interval,
+      @Nullable List<String> versions,
+      DateTime updateTime
+  );
 
   /**
-   * Deletes the segments for the given IDs from the metadata store.
+   * Permanently deletes the segments for the given IDs from the metadata store.
    *
    * @return Number of segments deleted successfully
    */
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/SegmentMetadataTransaction.java b/server/src/main/java/org/apache/druid/metadata/segment/SegmentMetadataTransaction.java
index 44ca620c2ea9..94a90ffe0d50 100644
--- a/server/src/main/java/org/apache/druid/metadata/segment/SegmentMetadataTransaction.java
+++ b/server/src/main/java/org/apache/druid/metadata/segment/SegmentMetadataTransaction.java
@@ -21,6 +21,8 @@
 
 import org.skife.jdbi.v2.Handle;
 
+import javax.annotation.Nullable;
+
 /**
  * Represents a single transaction involving read/write of segment metadata into
  * the metadata store. A transaction is associated with a single instance of a
@@ -40,6 +42,7 @@ public interface SegmentMetadataTransaction
   @FunctionalInterface
   interface Callback<T>
   {
+    @Nullable
     T inTransaction(SegmentMetadataTransaction transaction) throws Exception;
   }
 }
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/SqlSegmentMetadataTransaction.java b/server/src/main/java/org/apache/druid/metadata/segment/SqlSegmentMetadataTransaction.java
index 0e753e4028c7..1866d7e10eb6 100644
--- a/server/src/main/java/org/apache/druid/metadata/segment/SqlSegmentMetadataTransaction.java
+++ b/server/src/main/java/org/apache/druid/metadata/segment/SqlSegmentMetadataTransaction.java
@@ -26,6 +26,7 @@
 import com.google.common.collect.Lists;
 import org.apache.druid.error.DruidException;
 import org.apache.druid.error.InternalServerError;
+import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.java.util.common.parsers.CloseableIterator;
 import org.apache.druid.metadata.MetadataStorageTablesConfig;
@@ -110,22 +111,22 @@ public void close()
   // READ METHODS
 
   @Override
-  public Set<String> findExistingSegmentIds(Set<DataSegment> segments)
+  public Set<String> findExistingSegmentIds(Set<SegmentId> segmentIds)
   {
     final Set<String> existingSegmentIds = new HashSet<>();
     final String sql = "SELECT id FROM %s WHERE id in (%s)";
 
-    List<List<DataSegment>> partitions = Lists.partition(
-        new ArrayList<>(segments),
+    List<List<SegmentId>> partitions = Lists.partition(
+        new ArrayList<>(segmentIds),
         MAX_SEGMENTS_PER_BATCH
     );
-    for (List<DataSegment> segmentList : partitions) {
-      String segmentIds = segmentList.stream().map(
-          segment -> "'" + StringUtils.escapeSql(segment.getId().toString()) + "'"
+    for (List<SegmentId> segmentIdList : partitions) {
+      String segmentIdsCsv = segmentIdList.stream().map(
+          id -> "'" + StringUtils.escapeSql(id.toString()) + "'"
       ).collect(Collectors.joining(","));
 
       existingSegmentIds.addAll(
-          handle.createQuery(StringUtils.format(sql, dbTables.getSegmentsTable(), segmentIds))
+          handle.createQuery(StringUtils.format(sql, dbTables.getSegmentsTable(), segmentIdsCsv))
                 .mapTo(String.class)
                 .list()
       );
@@ -161,13 +162,9 @@ public Set<DataSegment> findUsedSegmentsOverlappingAnyOf(List<Interval> interval
   }
 
   @Override
-  public List<DataSegment> findUsedSegments(Set<SegmentId> segmentIds)
+  public List<DataSegmentPlus> findUsedSegments(Set<SegmentId> segmentIds)
   {
-    final Set<String> serializedIds = segmentIds.stream().map(SegmentId::toString).collect(Collectors.toSet());
-    return query.retrieveSegmentsById(dataSource, serializedIds)
-                .stream()
-                .map(DataSegmentPlus::getDataSegment)
-                .collect(Collectors.toList());
+    return query.retrieveSegmentsById(dataSource, segmentIds);
   }
 
   @Override
@@ -185,23 +182,23 @@ public Set<DataSegmentPlus> findUsedSegmentsPlusOverlappingAnyOf(List<Interval>
   @Override
   public DataSegment findSegment(SegmentId segmentId)
   {
-    return query.retrieveSegmentForId(segmentId.toString());
+    return query.retrieveSegmentForId(segmentId);
   }
 
   @Override
   public DataSegment findUsedSegment(SegmentId segmentId)
   {
-    return query.retrieveUsedSegmentForId(segmentId.toString());
+    return query.retrieveUsedSegmentForId(segmentId);
   }
 
   @Override
-  public List<DataSegmentPlus> findSegments(Set<String> segmentIds)
+  public List<DataSegmentPlus> findSegments(Set<SegmentId> segmentIds)
   {
     return query.retrieveSegmentsById(dataSource, segmentIds);
   }
 
   @Override
-  public List<DataSegmentPlus> findSegmentsWithSchema(Set<String> segmentIds)
+  public List<DataSegmentPlus> findSegmentsWithSchema(Set<SegmentId> segmentIds)
   {
     return query.retrieveSegmentsWithSchemaById(dataSource, segmentIds);
   }
@@ -267,9 +264,27 @@ public int insertSegmentsWithMetadata(Set<DataSegmentPlus> segments)
   }
 
   @Override
-  public int markSegmentsWithinIntervalAsUnused(Interval interval, DateTime updateTime)
+  public boolean markSegmentAsUnused(SegmentId segmentId, DateTime updateTime)
+  {
+    return query.markSegments(Set.of(segmentId), false, updateTime) > 0;
+  }
+
+  @Override
+  public int markSegmentsAsUnused(Set<SegmentId> segmentIds, DateTime updateTime)
+  {
+    return query.markSegments(segmentIds, false, updateTime);
+  }
+
+  @Override
+  public int markAllSegmentsAsUnused(DateTime updateTime)
+  {
+    return query.markSegmentsUnused(dataSource, Intervals.ETERNITY, null, updateTime);
+  }
+
+  @Override
+  public int markSegmentsWithinIntervalAsUnused(Interval interval, @Nullable List<String> versions, DateTime updateTime)
   {
-    return query.markSegmentsUnused(dataSource, interval, updateTime);
+    return query.markSegmentsUnused(dataSource, interval, versions, updateTime);
   }
 
   @Override
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/SqlSegmentMetadataTransactionFactory.java b/server/src/main/java/org/apache/druid/metadata/segment/SqlSegmentMetadataTransactionFactory.java
index 5a6adbdf8fff..0d8b707bded5 100644
--- a/server/src/main/java/org/apache/druid/metadata/segment/SqlSegmentMetadataTransactionFactory.java
+++ b/server/src/main/java/org/apache/druid/metadata/segment/SqlSegmentMetadataTransactionFactory.java
@@ -89,7 +89,7 @@ public <T> T inReadOnlyDatasourceTransaction(
 
             return datasourceCache.read(() -> executeReadAndClose(cachedTransaction, callback));
           } else {
-            return executeReadAndClose(createSqlTransaction(dataSource, handle, status), callback);
+            return executeReadAndClose(sqlTransaction, callback);
           }
         },
         QUIET_RETRIES,
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/cache/CacheStats.java b/server/src/main/java/org/apache/druid/metadata/segment/cache/CacheStats.java
new file mode 100644
index 000000000000..0e26b74b7afc
--- /dev/null
+++ b/server/src/main/java/org/apache/druid/metadata/segment/cache/CacheStats.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.metadata.segment.cache;
+
+/**
+ * Summary of current contents of the cache.
+ */
+public class CacheStats
+{
+  private final int numUsedSegments;
+  private final int numUnusedSegments;
+  private final int numIntervals;
+  private final int numPendingSegments;
+
+  public CacheStats(int numIntervals, int numUsedSegments, int numUnusedSegments, int numPendingSegments)
+  {
+    this.numUsedSegments = numUsedSegments;
+    this.numUnusedSegments = numUnusedSegments;
+    this.numIntervals = numIntervals;
+    this.numPendingSegments = numPendingSegments;
+  }
+
+  public int getNumUsedSegments()
+  {
+    return numUsedSegments;
+  }
+
+  public int getNumUnusedSegments()
+  {
+    return numUnusedSegments;
+  }
+
+  public int getNumIntervals()
+  {
+    return numIntervals;
+  }
+
+  public int getNumPendingSegments()
+  {
+    return numPendingSegments;
+  }
+}
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemoryDatasourceSegmentCache.java b/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemoryDatasourceSegmentCache.java
index bba303655cee..4a3b81505f24 100644
--- a/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemoryDatasourceSegmentCache.java
+++ b/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemoryDatasourceSegmentCache.java
@@ -84,39 +84,6 @@ boolean isEmpty()
     return withReadLock(intervalToSegments::isEmpty);
   }
 
-  /**
-   * Checks if a segment needs to be refreshed. A refresh is required if the
-   * cache has no entry for the given segment or if the metadata store has a
-   * more recently updated copy of the segment.
-   *
-   * @param persistedUpdateTime Last updated time of this segment as persisted
-   *                            in the metadata store. This value can be null
-   *                            for segments persisted before the column
-   *                            used_status_last_updated was added to the table.
-   */
-  boolean shouldRefreshUsedSegment(SegmentId segmentId, @Nullable DateTime persistedUpdateTime)
-  {
-    return withReadLock(() -> {
-      final DataSegmentPlus cachedState = readSegmentsFor(segmentId.getInterval())
-          .idToUsedSegment.get(segmentId);
-      return cachedState == null
-             || shouldUpdateCache(cachedState.getUsedStatusLastUpdatedDate(), persistedUpdateTime);
-    });
-  }
-
-  /**
-   * Checks if a pending segment needs to be refreshed in the cache.
-   */
-  boolean shouldRefreshPendingSegment(PendingSegmentRecord record)
-  {
-    final SegmentIdWithShardSpec segmentId = record.getId();
-    return withReadLock(
-        () -> !readSegmentsFor(segmentId.getInterval())
-            .idToPendingSegment
-            .containsKey(segmentId.toString())
-    );
-  }
-
   /**
    * Checks if a record in the cache needs to be updated.
    *
@@ -124,7 +91,7 @@ boolean shouldRefreshPendingSegment(PendingSegmentRecord record)
    * @param newUpdateTime    Updated time of record being considered to replace
    *                         the existing one
    */
-  private boolean shouldUpdateCache(
+  private static boolean shouldUpdateCache(
       @Nullable DateTime cachedUpdateTime,
       @Nullable DateTime newUpdateTime
   )
@@ -140,65 +107,66 @@ private boolean shouldUpdateCache(
   }
 
   /**
-   * Adds or updates the given segment in the cache.
+   * Atomically updates segment IDs in the cache based on the segments
+   * currently present in the metadata store.
    *
-   * @return true if the segment was updated in the cache, false if the segment
-   * was left unchanged in the cache.
+   * @param persistedSegments All segments present in the metadata store.
+   * @param syncStartTime     Start time of the current sync
+   * @return Summary of updates made to the cache.
    */
-  boolean addSegment(DataSegmentPlus segmentPlus)
+  SegmentSyncResult syncSegmentIds(List<SegmentRecord> persistedSegments, DateTime syncStartTime)
   {
-    if (Boolean.TRUE.equals(segmentPlus.getUsed())) {
-      return addUsedSegment(segmentPlus);
-    } else {
-      return addUnusedSegmentId(
-          segmentPlus.getDataSegment().getId(),
-          segmentPlus.getUsedStatusLastUpdatedDate()
-      );
-    }
-  }
-
-  /**
-   * Adds or updates a used segment in the cache.
-   */
-  private boolean addUsedSegment(DataSegmentPlus segmentPlus)
-  {
-    final DataSegment segment = segmentPlus.getDataSegment();
-    final SegmentId segmentId = segment.getId();
-
     return withWriteLock(() -> {
-      if (!shouldRefreshUsedSegment(segmentId, segmentPlus.getUsedStatusLastUpdatedDate())) {
-        return false;
+      final Set<SegmentId> usedSegmentIdsToRefresh = new HashSet<>();
+
+      for (SegmentRecord record : persistedSegments) {
+        final SegmentId segmentId = record.getSegmentId();
+        final SegmentsInInterval intervalSegments = writeSegmentsFor(segmentId.getInterval());
+
+        if (record.isUsed()) {
+          // Refresh this used segment if it has been updated in the metadata store
+          if (intervalSegments.shouldRefreshSegment(segmentId, record.getLastUpdatedTime())) {
+            usedSegmentIdsToRefresh.add(segmentId);
+          }
+        } else {
+          // Ignore unused segments
+        }
       }
 
-      final SegmentsInInterval segments = writeSegmentsFor(segmentId.getInterval());
-      segments.idToUsedSegment.put(segmentId, segmentPlus);
-      segments.unusedSegmentIdToUpdatedTime.remove(segment.getId());
-      return true;
+      // Remove unknown segments from cache
+      final Set<SegmentId> persistedSegmentIds
+          = persistedSegments.stream().map(SegmentRecord::getSegmentId).collect(Collectors.toSet());
+      final int numSegmentsRemoved = removeUnpersistedSegments(persistedSegmentIds, syncStartTime);
+
+      return new SegmentSyncResult(numSegmentsRemoved, 0, usedSegmentIdsToRefresh);
     });
   }
 
   /**
-   * Adds or updates an unused segment in the cache.
+   * Atomically updates pending segments in the cache based on the segments
+   * currently present in the metadata store.
    *
-   * @param updatedTime Last updated time of this segment as persisted in the
-   *                    metadata store. This value can be null for segments
-   *                    persisted to the metadata store before the column
-   *                    used_status_last_updated was added to the segments table.
+   * @param persistedPendingSegments All pending segments present in the metadata store.
+   * @param syncStartTime            Start time of the current sync
+   * @return Summary of updates made to the cache.
    */
-  boolean addUnusedSegmentId(SegmentId segmentId, @Nullable DateTime updatedTime)
+  SegmentSyncResult syncPendingSegments(
+      List<PendingSegmentRecord> persistedPendingSegments,
+      DateTime syncStartTime
+  )
   {
     return withWriteLock(() -> {
-      final SegmentsInInterval segmentsInInterval = writeSegmentsFor(segmentId.getInterval());
-      segmentsInInterval.idToUsedSegment.remove(segmentId);
-
-      if (!segmentsInInterval.unusedSegmentIdToUpdatedTime.containsKey(segmentId)
-          || shouldUpdateCache(segmentsInInterval.unusedSegmentIdToUpdatedTime.get(segmentId), updatedTime)) {
-        segmentsInInterval.unusedSegmentIdToUpdatedTime.put(segmentId, updatedTime);
-        segmentsInInterval.updateMaxUnusedId(segmentId);
-        return true;
-      } else {
-        return false;
+      int numSegmentsUpdated = 0;
+      for (PendingSegmentRecord record : persistedPendingSegments) {
+        if (insertPendingSegment(record, false)) {
+          ++numSegmentsUpdated;
+        }
       }
+
+      final Set<String> persistedSegmentIds
+          = persistedPendingSegments.stream().map(s -> s.getId().toString()).collect(Collectors.toSet());
+      final int numSegmentsRemoved = removeUnpersistedPendingSegments(persistedSegmentIds, syncStartTime);
+      return new SegmentSyncResult(numSegmentsRemoved, numSegmentsUpdated, Set.of());
     });
   }
 
@@ -206,7 +174,7 @@ boolean addUnusedSegmentId(SegmentId segmentId, @Nullable DateTime updatedTime)
    * Removes all pending segments which are present in the cache but not present
    * in the metadata store.
    */
-  int removeUnpersistedPendingSegments(Set<String> persistedPendingSegmentIds, DateTime pollStartTime)
+  private int removeUnpersistedPendingSegments(Set<String> persistedPendingSegmentIds, DateTime pollStartTime)
   {
     return withWriteLock(() -> {
       final Set<String> unpersistedSegmentIds =
@@ -226,7 +194,7 @@ && shouldUpdateCache(record.getCreatedDate(), pollStartTime)
    * @param syncStartTime       Start time of the current sync
    * @return Number of unpersisted segments removed from cache.
    */
-  int removeUnpersistedSegments(Set<SegmentId> persistedSegmentIds, DateTime syncStartTime)
+  private int removeUnpersistedSegments(Set<SegmentId> persistedSegmentIds, DateTime syncStartTime)
   {
     return withWriteLock(() -> {
       final Set<SegmentId> unpersistedSegmentIds = new HashSet<>();
@@ -243,53 +211,19 @@ && shouldUpdateCache(entry.getValue().getUsedStatusLastUpdatedDate(), syncStartT
         ).map(Map.Entry::getKey).forEach(unpersistedSegmentIds::add);
       }
 
-      return removeSegmentsForIds(unpersistedSegmentIds);
+      return deleteSegments(unpersistedSegmentIds);
     });
   }
 
   /**
-   * Removes the segments for the given IDs (used or unused) from the cache.
-   *
-   * @return Number of used and unused segments removed
+   * Indicates to the cache that it has now been synced with the metadata store.
+   * Removes empty intervals from the cache and returns the summary of the current
+   * contents of the cache.
    */
-  int removeSegmentsForIds(Set<SegmentId> segmentIds)
+  CacheStats markCacheSynced()
   {
     return withWriteLock(() -> {
-      int removedCount = 0;
-      for (SegmentId segmentId : segmentIds) {
-        if (segmentId == null) {
-          continue;
-        }
-
-        final SegmentsInInterval segmentsInInterval = writeSegmentsFor(segmentId.getInterval());
-        final DataSegmentPlus segment = segmentsInInterval.idToUsedSegment.remove(segmentId);
-        if (segment != null) {
-          ++removedCount;
-        } else if (segmentsInInterval.unusedSegmentIdToUpdatedTime.containsKey(segmentId)) {
-          segmentsInInterval.unusedSegmentIdToUpdatedTime.remove(segmentId);
-          ++removedCount;
-        }
-      }
-
-      return removedCount;
-    });
-  }
-
-  /**
-   * Indicates to the cache that it has now been synced with the metadata store.
-   */
-  void markCacheSynced()
-  {
-    // Recompute the highest unused IDs for every interval / version
-    withWriteLock(
-        () -> intervalToSegments.values().forEach(segments -> {
-          segments.versionToHighestUnusedPartitionNumber.clear();
-          segments.unusedSegmentIdToUpdatedTime.keySet().forEach(segments::updateMaxUnusedId);
-        })
-    );
-
-    // Remove empty intervals
-    withWriteLock(() -> {
+      // Remove empty intervals
       final Set<Interval> emptyIntervals =
           intervalToSegments.entrySet()
                             .stream()
@@ -297,14 +231,43 @@ void markCacheSynced()
                             .map(Map.Entry::getKey)
                             .collect(Collectors.toSet());
       emptyIntervals.forEach(intervalToSegments::remove);
+
+      return getCacheStats();
     });
   }
 
+  /**
+   * Returns a summary of the current contents of the cache.
+   */
+  private CacheStats getCacheStats()
+  {
+    return withWriteLock(() -> {
+      int numUsedSegments = 0;
+      int numUnusedSegments = 0;
+      int numPendingSegments = 0;
+      int numIntervals = 0;
+      for (SegmentsInInterval segments : intervalToSegments.values()) {
+        ++numIntervals;
+        numUsedSegments += segments.idToUsedSegment.size();
+        numUnusedSegments += segments.unusedSegmentIdToUpdatedTime.size();
+        numPendingSegments += segments.idToPendingSegment.size();
+      }
+
+      return new CacheStats(numIntervals, numUsedSegments, numUnusedSegments, numPendingSegments);
+    });
+  }
+
+  /**
+   * Must be accessed within a {@link #withReadLock} method.
+   */
   private SegmentsInInterval readSegmentsFor(Interval interval)
   {
     return intervalToSegments.getOrDefault(interval, SegmentsInInterval.EMPTY);
   }
 
+  /**
+   * Must be accessed within a {@link #withWriteLock} method.
+   */
   private SegmentsInInterval writeSegmentsFor(Interval interval)
   {
     return intervalToSegments.computeIfAbsent(interval, i -> new SegmentsInInterval());
@@ -313,15 +276,9 @@ private SegmentsInInterval writeSegmentsFor(Interval interval)
   // CACHE READ METHODS
 
   @Override
-  public Set<String> findExistingSegmentIds(Set<DataSegment> segments)
+  public Set<String> findExistingSegmentIds(Set<SegmentId> segments)
   {
-    return withReadLock(
-        () -> segments.stream()
-                      .map(DataSegment::getId)
-                      .filter(id -> readSegmentsFor(id.getInterval()).isSegmentIdCached(id))
-                      .map(SegmentId::toString)
-                      .collect(Collectors.toSet())
-    );
+    throw DruidException.defensive("Unsupported: Unused segments are not cached");
   }
 
   @Override
@@ -336,14 +293,7 @@ public Set<SegmentId> findUsedSegmentIdsOverlapping(Interval interval)
   @Override
   public SegmentId findHighestUnusedSegmentId(Interval interval, String version)
   {
-    final Integer highestPartitionNum =
-        readSegmentsFor(interval)
-            .versionToHighestUnusedPartitionNumber
-            .get(version);
-
-    return highestPartitionNum == null
-           ? null
-           : SegmentId.of(dataSource, interval, version, highestPartitionNum);
+    throw DruidException.defensive("Unsupported: Unused segments are not cached");
   }
 
   @Override
@@ -356,13 +306,12 @@ public Set<DataSegment> findUsedSegmentsOverlappingAnyOf(List<Interval> interval
   }
 
   @Override
-  public List<DataSegment> findUsedSegments(Set<SegmentId> segmentIds)
+  public List<DataSegmentPlus> findUsedSegments(Set<SegmentId> segmentIds)
   {
     return withReadLock(
         () -> segmentIds.stream()
                         .map(id -> readSegmentsFor(id.getInterval()).idToUsedSegment.get(id))
                         .filter(Objects::nonNull)
-                        .map(DataSegmentPlus::getDataSegment)
                         .collect(Collectors.toList())
     );
   }
@@ -405,13 +354,13 @@ public DataSegment findUsedSegment(SegmentId segmentId)
   }
 
   @Override
-  public List<DataSegmentPlus> findSegments(Set<String> segmentIds)
+  public List<DataSegmentPlus> findSegments(Set<SegmentId> segmentIds)
   {
     throw DruidException.defensive("Unsupported: Unused segments are not cached");
   }
 
   @Override
-  public List<DataSegmentPlus> findSegmentsWithSchema(Set<String> segmentIds)
+  public List<DataSegmentPlus> findSegmentsWithSchema(Set<SegmentId> segmentIds)
   {
     throw DruidException.defensive("Unsupported: Unused segments are not cached");
   }
@@ -485,7 +434,8 @@ public int insertSegments(Set<DataSegmentPlus> segments)
     return withWriteLock(() -> {
       int numInsertedSegments = 0;
       for (DataSegmentPlus segmentPlus : segments) {
-        if (addSegment(segmentPlus)) {
+        final Interval interval = segmentPlus.getDataSegment().getInterval();
+        if (writeSegmentsFor(interval).addSegment(segmentPlus)) {
           ++numInsertedSegments;
         }
       }
@@ -501,23 +451,82 @@ public int insertSegmentsWithMetadata(Set<DataSegmentPlus> segments)
   }
 
   @Override
-  public int markSegmentsWithinIntervalAsUnused(Interval interval, DateTime updateTime)
+  public boolean markSegmentAsUnused(SegmentId segmentId, DateTime updateTime)
   {
-    int updatedCount = 0;
-    for (DataSegment segment : findUsedSegmentsOverlappingAnyOf(List.of(interval))) {
-      boolean updated = addUnusedSegmentId(segment.getId(), updateTime);
-      if (updated) {
-        ++updatedCount;
+    return writeSegmentsFor(segmentId.getInterval()).markSegmentAsUnused(segmentId, updateTime);
+  }
+
+  @Override
+  public int markSegmentsAsUnused(Set<SegmentId> segmentIds, DateTime updateTime)
+  {
+    return withWriteLock(() -> {
+      int updatedCount = 0;
+      for (SegmentId segmentId : segmentIds) {
+        final Interval interval = segmentId.getInterval();
+        if (writeSegmentsFor(interval).markSegmentAsUnused(segmentId, updateTime)) {
+          ++updatedCount;
+        }
       }
-    }
+      return updatedCount;
+    });
+  }
 
-    return updatedCount;
+  @Override
+  public int markSegmentsWithinIntervalAsUnused(
+      Interval interval,
+      @Nullable List<String> versions,
+      DateTime updateTime
+  )
+  {
+    final Set<String> eligibleVersions = versions == null ? null : Set.copyOf(versions);
+
+    return withWriteLock(() -> {
+      int updatedCount = 0;
+      for (DataSegmentPlus segmentPlus : findUsedSegmentsPlusOverlappingAnyOf(List.of(interval))) {
+        // Update segments with eligible versions or all versions (if eligibleVersions is null)
+        final DataSegment segment = segmentPlus.getDataSegment();
+        final boolean isEligibleVersion = eligibleVersions == null
+                                          || eligibleVersions.contains(segment.getVersion());
+        if (isEligibleVersion
+            && writeSegmentsFor(segment.getInterval()).markSegmentAsUnused(segment.getId(), updateTime)) {
+          ++updatedCount;
+        }
+      }
+
+      return updatedCount;
+    });
+  }
+
+  @Override
+  public int markAllSegmentsAsUnused(DateTime updateTime)
+  {
+    return withWriteLock(() -> {
+      int updatedCount = 0;
+      for (DataSegmentPlus segmentPlus : findUsedSegmentsPlusOverlappingAnyOf(List.of())) {
+        final DataSegment segment = segmentPlus.getDataSegment();
+        if (writeSegmentsFor(segment.getInterval())
+            .markSegmentAsUnused(segment.getId(), updateTime)) {
+          ++updatedCount;
+        }
+      }
+
+      return updatedCount;
+    });
   }
 
   @Override
   public int deleteSegments(Set<SegmentId> segmentIdsToDelete)
   {
-    return removeSegmentsForIds(segmentIdsToDelete);
+    return withWriteLock(() -> {
+      int deletedCount = 0;
+      for (SegmentId segmentId : segmentIdsToDelete) {
+        if (segmentId != null
+            && writeSegmentsFor(segmentId.getInterval()).removeSegment(segmentId)) {
+          ++deletedCount;
+        }
+      }
+      return deletedCount;
+    });
   }
 
   @Override
@@ -662,13 +671,11 @@ private static class SegmentsInInterval
     final Map<String, PendingSegmentRecord> idToPendingSegment = new HashMap<>();
 
     /**
-     * Map from version to the highest partition number of an unused segment with
-     * that version.
-     */
-    final Map<String, Integer> versionToHighestUnusedPartitionNumber = new HashMap<>();
-
-    /**
-     * Map from segment ID to updated time for unused segments only.
+     * Map from segment ID to updated time for segments that have been recently
+     * marked as unused. This map is needed to handle race conditions with sync.
+     * For example, if a segment has just been marked as unused, the latest poll
+     * from metadata store might still show that segment as used. Checking with
+     * this map ensures that such a segment is not added back to the cache.
      */
     final Map<SegmentId, DateTime> unusedSegmentIdToUpdatedTime = new HashMap<>();
 
@@ -676,14 +683,14 @@ void clear()
     {
       idToPendingSegment.clear();
       idToUsedSegment.clear();
-      versionToHighestUnusedPartitionNumber.clear();
+      unusedSegmentIdToUpdatedTime.clear();
     }
 
     boolean isEmpty()
     {
       return idToPendingSegment.isEmpty()
              && idToUsedSegment.isEmpty()
-             && versionToHighestUnusedPartitionNumber.isEmpty();
+             && unusedSegmentIdToUpdatedTime.isEmpty();
     }
 
     private boolean isSegmentIdCached(SegmentId id)
@@ -692,10 +699,72 @@ private boolean isSegmentIdCached(SegmentId id)
              || unusedSegmentIdToUpdatedTime.containsKey(id);
     }
 
-    private void updateMaxUnusedId(SegmentId segmentId)
+    /**
+     * Removes the given segment from the cache.
+     *
+     * @return true if the segment was removed, false otherwise
+     */
+    private boolean removeSegment(SegmentId segmentId)
+    {
+      if (idToUsedSegment.containsKey(segmentId)) {
+        idToUsedSegment.remove(segmentId);
+        return true;
+      } else if (unusedSegmentIdToUpdatedTime.containsKey(segmentId)) {
+        unusedSegmentIdToUpdatedTime.remove(segmentId);
+        return true;
+      } else {
+        return false;
+      }
+    }
+
+    /**
+     * Adds or updates the given segment in the cache.
+     *
+     * @return true if the segment was updated in the cache, false if the segment
+     * was left unchanged in the cache.
+     */
+    boolean addSegment(DataSegmentPlus segmentPlus)
     {
-      versionToHighestUnusedPartitionNumber
-          .merge(segmentId.getVersion(), segmentId.getPartitionNum(), Math::max);
+      final SegmentId segmentId = segmentPlus.getDataSegment().getId();
+      if (!shouldRefreshSegment(segmentId, segmentPlus.getUsedStatusLastUpdatedDate())) {
+        return false;
+      } else if (Boolean.TRUE.equals(segmentPlus.getUsed())) {
+        idToUsedSegment.put(segmentId, segmentPlus);
+        unusedSegmentIdToUpdatedTime.remove(segmentId);
+        return true;
+      } else {
+        return markSegmentAsUnused(segmentId, segmentPlus.getUsedStatusLastUpdatedDate());
+      }
+    }
+
+    /**
+     * Marks the given segment as unused segment in the cache.
+     *
+     * @param updatedTime Last updated time of this segment as persisted in the
+     *                    metadata store. This value can be null for segments
+     *                    persisted to the metadata store before the column
+     *                    used_status_last_updated was added to the segments table.
+     */
+    private boolean markSegmentAsUnused(SegmentId segmentId, @Nullable DateTime updatedTime)
+    {
+      if (shouldRefreshSegment(segmentId, updatedTime)) {
+        idToUsedSegment.remove(segmentId);
+        unusedSegmentIdToUpdatedTime.put(segmentId, updatedTime);
+        return true;
+      } else {
+        return false;
+      }
+    }
+
+    private boolean shouldRefreshSegment(SegmentId segmentId, DateTime newUpdateTime)
+    {
+      if (unusedSegmentIdToUpdatedTime.containsKey(segmentId)) {
+        return shouldUpdateCache(unusedSegmentIdToUpdatedTime.get(segmentId), newUpdateTime);
+      } else {
+        final DataSegmentPlus usedSegment = idToUsedSegment.get(segmentId);
+        return usedSegment == null
+            || shouldUpdateCache(usedSegment.getUsedStatusLastUpdatedDate(), newUpdateTime);
+      }
     }
   }
 }
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCache.java b/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCache.java
index 2d177509547b..b51f1e026a0a 100644
--- a/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCache.java
+++ b/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCache.java
@@ -35,6 +35,7 @@
 import org.apache.druid.java.util.common.Stopwatch;
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.java.util.common.concurrent.ScheduledExecutorFactory;
+import org.apache.druid.java.util.common.jackson.JacksonUtils;
 import org.apache.druid.java.util.common.parsers.CloseableIterator;
 import org.apache.druid.java.util.emitter.EmittingLogger;
 import org.apache.druid.java.util.emitter.service.ServiceEmitter;
@@ -46,17 +47,18 @@
 import org.apache.druid.metadata.SqlSegmentsMetadataQuery;
 import org.apache.druid.query.DruidMetrics;
 import org.apache.druid.server.http.DataSegmentPlus;
+import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.SegmentId;
 import org.joda.time.DateTime;
 import org.joda.time.Duration;
-import org.joda.time.Interval;
 import org.skife.jdbi.v2.ResultIterator;
 import org.skife.jdbi.v2.TransactionCallback;
 
-import javax.annotation.Nullable;
 import java.sql.ResultSet;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.CancellationException;
@@ -67,6 +69,19 @@
 
 /**
  * In-memory implementation of {@link SegmentMetadataCache}.
+ * <p>
+ * Only used segments (excluding num_rows and schema_fingerpring) and
+ * pending segments are cached. Unused segments are not cached.
+ * <p>
+ * Non-leader Overlords also keep polling the metadata store to keep the cache
+ * up-to-date in case leadership changes.
+ * <p>
+ * The map {@link #datasourceToSegmentCache} contains the cache for each datasource.
+ * Items are only added to this map and never removed. This is to avoid handling
+ * race conditions where a thread has invoked {@link #getDatasource} but hasn't
+ * acquired a lock on the returned cache yet while another thread sees this cache
+ * as empty and cleans it up. The first thread would then end up using a stopped
+ * cache, resulting in errors.
  */
 @ThreadSafe
 public class HeapMemorySegmentMetadataCache implements SegmentMetadataCache
@@ -103,6 +118,7 @@ private enum CacheState
   private CacheState currentCacheState = CacheState.STOPPED;
   @GuardedBy("cacheStateLock")
   private ListenableFuture<Long> nextSyncFuture = null;
+  @GuardedBy("cacheStateLock")
   private int consecutiveSyncFailures = 0;
 
   private final ConcurrentHashMap<String, HeapMemoryDatasourceSegmentCache>
@@ -156,6 +172,7 @@ public void stop()
         pollExecutor.shutdownNow();
         datasourceToSegmentCache.forEach((datasource, cache) -> cache.stop());
         datasourceToSegmentCache.clear();
+        syncFinishTime.set(null);
 
         updateCacheState(CacheState.STOPPED, "Stopped sync with metadata store");
       }
@@ -256,7 +273,7 @@ private void waitForCacheToFinishSync()
           log.noStackTrace().info(e, "Interrupted while waiting for cache to be ready");
         }
         catch (Exception e) {
-          log.noStackTrace().error(e, "Error while waiting for cache to be ready");
+          log.error(e, "Error while waiting for cache to be ready");
           throw DruidException.defensive(e, "Error while waiting for cache to be ready");
         }
       }
@@ -305,7 +322,6 @@ public void onSuccess(Long previousSyncDurationMillis)
               }
 
               emitMetric(Metric.SYNC_DURATION_MILLIS, previousSyncDurationMillis);
-              syncFinishTime.set(DateTimes.nowUtc());
 
               // Schedule the next sync
               final long nextSyncDelay;
@@ -369,8 +385,8 @@ public void onFailure(Throwable t)
    */
   private long syncWithMetadataStore()
   {
-    final DateTime pollStartTime = DateTimes.nowUtc();
-    final Stopwatch sincePollStart = Stopwatch.createStarted();
+    final DateTime syncStartTime = DateTimes.nowUtc();
+    final Stopwatch totalSyncDuration = Stopwatch.createStarted();
 
     synchronized (cacheStateLock) {
       if (currentCacheState == CacheState.LEADER_FIRST_SYNC_PENDING) {
@@ -382,98 +398,90 @@ private long syncWithMetadataStore()
     }
 
     final Map<String, DatasourceSegmentSummary> datasourceToSummary = new HashMap<>();
-    retrieveAllSegmentIds(datasourceToSummary);
-
-    datasourceToSegmentCache.keySet().forEach(
-        dataSource -> removeUnknownSegmentsFromCache(
-            dataSource,
-            datasourceToSummary.computeIfAbsent(dataSource, ds -> new DatasourceSegmentSummary()),
-            pollStartTime
-        )
-    );
 
-    datasourceToSummary.forEach(this::retrieveAndRefreshUsedSegments);
+    // Fetch all used segments if this is the first sync
+    if (syncFinishTime.get() == null) {
+      retrieveAllUsedSegments(datasourceToSummary);
+    } else {
+      retrieveAllSegmentIds(datasourceToSummary);
+      updateSegmentIdsInCache(datasourceToSummary, syncStartTime);
+      retrieveUsedSegmentPayloads(datasourceToSummary);
+    }
 
-    retrieveAndRefreshAllPendingSegments(datasourceToSummary);
-    datasourceToSegmentCache.keySet().forEach(
-        dataSource -> removeUnknownPendingSegmentsFromCache(
-            dataSource,
-            datasourceToSummary.computeIfAbsent(dataSource, ds -> new DatasourceSegmentSummary()),
-            pollStartTime
-        )
-    );
+    updateUsedSegmentPayloadsInCache(datasourceToSummary);
+    retrieveAllPendingSegments(datasourceToSummary);
+    updatePendingSegmentsInCache(datasourceToSummary, syncStartTime);
+    markCacheSynced();
 
-    datasourceToSegmentCache.values().forEach(
-        HeapMemoryDatasourceSegmentCache::markCacheSynced
-    );
+    syncFinishTime.set(DateTimes.nowUtc());
+    return totalSyncDuration.millisElapsed();
+  }
 
-    datasourceToSummary.forEach(this::emitSummaryMetrics);
-    return sincePollStart.millisElapsed();
+  /**
+   * Marks the cache for all datasources as synced and emit total stats.
+   */
+  private void markCacheSynced()
+  {
+    datasourceToSegmentCache.forEach((dataSource, cache) -> {
+      final CacheStats stats = cache.markCacheSynced();
+
+      if (!cache.isEmpty()) {
+        emitMetric(dataSource, Metric.CACHED_INTERVALS, stats.getNumIntervals());
+        emitMetric(dataSource, Metric.CACHED_USED_SEGMENTS, stats.getNumUsedSegments());
+        emitMetric(dataSource, Metric.CACHED_UNUSED_SEGMENTS, stats.getNumUnusedSegments());
+        emitMetric(dataSource, Metric.CACHED_PENDING_SEGMENTS, stats.getNumPendingSegments());
+      }
+    });
   }
 
   /**
-   * Retrieves all the segment IDs (used and unused) from the metadata store.
+   * Retrieves all used segment IDs from the metadata store.
    * Populates the summary for the datasources found in metadata store.
    */
   private void retrieveAllSegmentIds(
       Map<String, DatasourceSegmentSummary> datasourceToSummary
   )
   {
+    final Stopwatch retrieveDuration = Stopwatch.createStarted();
     final String sql = StringUtils.format(
-        "SELECT id, dataSource, used, used_status_last_updated FROM %s",
+        "SELECT id, dataSource, used_status_last_updated FROM %s WHERE used = true",
         tablesConfig.getSegmentsTable()
     );
 
-    final AtomicInteger numSkippedRecords = new AtomicInteger(0);
-    inReadOnlyTransaction((handle, status) -> {
+    final int numSkippedRecords = inReadOnlyTransaction((handle, status) -> {
       try (
           ResultIterator<SegmentRecord> iterator =
               handle.createQuery(sql)
+                    .setFetchSize(connector.getStreamingFetchSize())
                     .map((index, r, ctx) -> SegmentRecord.fromResultSet(r))
                     .iterator()
       ) {
+        int skippedRecords = 0;
         while (iterator.hasNext()) {
           final SegmentRecord record = iterator.next();
           if (record == null) {
-            numSkippedRecords.incrementAndGet();
-            continue;
-          }
-
-          final SegmentId segmentId = record.segmentId;
-          final HeapMemoryDatasourceSegmentCache cache = getCacheForDatasource(record.dataSource);
-          final DatasourceSegmentSummary summary = datasourceToSummary
-              .computeIfAbsent(record.dataSource, ds -> new DatasourceSegmentSummary());
-
-          if (record.isUsed) {
-            summary.numPersistedUsedSegments++;
-
-            // Check if the used segment needs to be refreshed
-            if (cache.shouldRefreshUsedSegment(segmentId, record.lastUpdatedTime)) {
-              summary.usedSegmentIdsToRefresh.add(record.segmentId.toString());
-            }
+            ++skippedRecords;
           } else {
-            summary.numPersistedUnusedSegments++;
-            if (cache.addUnusedSegmentId(segmentId, record.lastUpdatedTime)) {
-              summary.numUnusedSegmentsUpdated++;
-            }
-
-            // Track max partition number of unused segment if needed
-            summary
-                .intervalVersionToMaxUnusedPartition
-                .computeIfAbsent(segmentId.getInterval(), i -> new HashMap<>())
-                .merge(segmentId.getVersion(), segmentId.getPartitionNum(), Math::max);
+            final SegmentId segmentId = record.getSegmentId();
+            datasourceToSummary
+                .computeIfAbsent(segmentId.getDataSource(), ds -> new DatasourceSegmentSummary())
+                .addSegmentRecord(record);
           }
-
-          summary.persistedSegmentIds.add(segmentId);
         }
 
-        return 0;
+        return skippedRecords;
       }
     });
 
-    if (numSkippedRecords.get() > 0) {
-      emitMetric(Metric.SKIPPED_SEGMENTS, numSkippedRecords.get());
+    // Emit metrics
+    if (numSkippedRecords > 0) {
+      emitMetric(Metric.SKIPPED_SEGMENTS, numSkippedRecords);
     }
+    datasourceToSummary.forEach(
+        (dataSource, summary) ->
+            emitMetric(dataSource, Metric.PERSISTED_USED_SEGMENTS, summary.persistedSegments.size())
+    );
+    emitMetric(Metric.RETRIEVE_SEGMENT_IDS_DURATION_MILLIS, retrieveDuration.millisElapsed());
   }
 
   private <T> T inReadOnlyTransaction(TransactionCallback<T> callback)
@@ -482,86 +490,186 @@ private <T> T inReadOnlyTransaction(TransactionCallback<T> callback)
   }
 
   /**
-   * Emits metrics for a datasource after the sync has finished.
-   * If there are no persisted or cached segments for the datasource, no metrics
-   * are emitted.
+   * Retrieves the payloads of required used segments from the metadata store
+   * and updates the cache. A segment needs to be refreshed only if
+   * {@link HeapMemoryDatasourceSegmentCache.SegmentsInInterval#shouldRefreshSegment}
+   * returns true for it.
    */
-  private void emitSummaryMetrics(String dataSource, DatasourceSegmentSummary summary)
+  private void retrieveRequiredUsedSegments(
+      String dataSource,
+      DatasourceSegmentSummary summary
+  )
   {
-    final HeapMemoryDatasourceSegmentCache cache = getCacheForDatasource(dataSource);
-    if (cache.isEmpty() && summary.isEmpty() && !summary.isCacheUpdated()) {
-      // This is non-existent datasource and has a dangling entry in the datasourceToSegmentCache map
+    final Set<SegmentId> segmentIdsToRefresh = summary.usedSegmentIdsToRefresh;
+    if (segmentIdsToRefresh.isEmpty()) {
       return;
     }
 
-    emitMetric(dataSource, Metric.PERSISTED_USED_SEGMENTS, summary.numPersistedUsedSegments);
-    emitMetric(dataSource, Metric.PERSISTED_UNUSED_SEGMENTS, summary.numPersistedUnusedSegments);
-    emitMetric(dataSource, Metric.PERSISTED_PENDING_SEGMENTS, summary.persistedPendingSegmentIds.size());
-    emitMetric(dataSource, Metric.STALE_USED_SEGMENTS, summary.usedSegmentIdsToRefresh.size());
-
-    emitNonZeroMetric(dataSource, Metric.DELETED_SEGMENTS, summary.numSegmentsRemoved);
-    emitNonZeroMetric(dataSource, Metric.DELETED_PENDING_SEGMENTS, summary.numPendingSegmentsRemoved);
-    emitNonZeroMetric(dataSource, Metric.UPDATED_USED_SEGMENTS, summary.numUsedSegmentsRefreshed);
-    emitNonZeroMetric(dataSource, Metric.UPDATED_UNUSED_SEGMENTS, summary.numUnusedSegmentsUpdated);
-    emitNonZeroMetric(dataSource, Metric.UPDATED_PENDING_SEGMENTS, summary.numPendingSegmentsUpdated);
-
-    if (summary.isCacheUpdated()) {
-      log.info(
-          "Updated metadata cache for datasource[%s]."
-          + " Added [%d] used, [%d] unused, [%d] pending segments."
-          + " Deleted [%d] segments, [%d] pending segments.",
-          dataSource, summary.numUsedSegmentsRefreshed,
-          summary.numUnusedSegmentsUpdated, summary.numPendingSegmentsUpdated,
-          summary.numSegmentsRemoved, summary.numPendingSegmentsRemoved
-      );
-    }
+    inReadOnlyTransaction((handle, status) -> {
+      try (
+          CloseableIterator<DataSegmentPlus> iterator =
+              SqlSegmentsMetadataQuery
+                  .forHandle(handle, connector, tablesConfig, jsonMapper)
+                  .retrieveSegmentsByIdIterator(dataSource, segmentIdsToRefresh, false)
+      ) {
+        iterator.forEachRemaining(summary.usedSegments::add);
+        return 0;
+      }
+    });
+  }
+
+  /**
+   * Updates the cache of each datasource with the segment IDs fetched from the
+   * metadata store in {@link #retrieveAllSegmentIds}. The update done on each
+   * datasource cache is atomic.
+   */
+  private void updateSegmentIdsInCache(
+      Map<String, DatasourceSegmentSummary> datasourceToSummary,
+      DateTime syncStartTime
+  )
+  {
+    final Stopwatch updateDuration = Stopwatch.createStarted();
+
+    // Sync segments for datasources which were retrieved in the latest poll
+    datasourceToSummary.forEach((dataSource, summary) -> {
+      final HeapMemoryDatasourceSegmentCache cache = getCacheForDatasource(dataSource);
+
+      final SegmentSyncResult result = cache.syncSegmentIds(summary.persistedSegments, syncStartTime);
+      emitNonZeroMetric(dataSource, Metric.STALE_USED_SEGMENTS, result.getExpiredIds().size());
+      emitNonZeroMetric(dataSource, Metric.DELETED_SEGMENTS, result.getDeleted());
+
+      summary.usedSegmentIdsToRefresh.addAll(result.getExpiredIds());
+    });
+
+    // Update cache for datasources which returned no segments in the latest poll
+    datasourceToSegmentCache.forEach((dataSource, cache) -> {
+      if (!datasourceToSummary.containsKey(dataSource)) {
+        final SegmentSyncResult result = cache.syncSegmentIds(List.of(), syncStartTime);
+        emitNonZeroMetric(dataSource, Metric.DELETED_SEGMENTS, result.getDeleted());
+      }
+    });
+
+    emitMetric(Metric.UPDATE_IDS_DURATION_MILLIS, updateDuration.millisElapsed());
   }
 
   /**
    * Retrieves the payloads of required used segments from the metadata store
    * and updates the cache. A segment needs to be refreshed only if
-   * {@link HeapMemoryDatasourceSegmentCache#shouldRefreshUsedSegment}
+   * {@link HeapMemoryDatasourceSegmentCache.SegmentsInInterval#shouldRefreshSegment}
    * returns true for it.
    */
-  private void retrieveAndRefreshUsedSegments(
-      String dataSource,
-      DatasourceSegmentSummary summary
+  private void retrieveUsedSegmentPayloads(
+      Map<String, DatasourceSegmentSummary> datasourceToSummary
   )
   {
-    if (summary.usedSegmentIdsToRefresh.isEmpty()) {
-      return;
-    }
+    final Stopwatch retrieveDuration = Stopwatch.createStarted();
+    datasourceToSummary.forEach(this::retrieveRequiredUsedSegments);
+    emitMetric(Metric.RETRIEVE_SEGMENT_PAYLOADS_DURATION_MILLIS, retrieveDuration.millisElapsed());
+  }
 
-    final HeapMemoryDatasourceSegmentCache cache = getCacheForDatasource(dataSource);
+  /**
+   * Retrieves all used segments from the metadata store.
+   * This method is called only on the first full sync.
+   */
+  private void retrieveAllUsedSegments(
+      Map<String, DatasourceSegmentSummary> datasourceToSummary
+  )
+  {
+    final Stopwatch retrieveDuration = Stopwatch.createStarted();
+    final String sql = StringUtils.format(
+        "SELECT id, payload, created_date, used_status_last_updated FROM %s WHERE used = true",
+        tablesConfig.getSegmentsTable()
+    );
 
-    summary.numUsedSegmentsRefreshed = inReadOnlyTransaction((handle, status) -> {
-      int updatedCount = 0;
+    final int numSkippedSegments = inReadOnlyTransaction((handle, status) -> {
       try (
-          CloseableIterator<DataSegmentPlus> iterator =
-              SqlSegmentsMetadataQuery
-                  .forHandle(handle, connector, tablesConfig, jsonMapper)
-                  .retrieveSegmentsByIdIterator(dataSource, summary.usedSegmentIdsToRefresh, false)
+          ResultIterator<DataSegmentPlus> iterator =
+              handle.createQuery(sql)
+                    .setFetchSize(connector.getStreamingFetchSize())
+                    .map((index, r, ctx) -> mapToSegmentPlus(r))
+                    .iterator()
       ) {
+        int skippedRecords = 0;
         while (iterator.hasNext()) {
-          if (cache.addSegment(iterator.next())) {
-            ++updatedCount;
+          final DataSegmentPlus segment = iterator.next();
+          if (segment == null) {
+            ++skippedRecords;
+          } else {
+            datasourceToSummary.computeIfAbsent(
+                segment.getDataSegment().getDataSource(),
+                ds -> new DatasourceSegmentSummary()
+            ).usedSegments.add(segment);
           }
         }
+
+        return skippedRecords;
       }
+    });
+
+    // Emit metrics
+    if (numSkippedSegments > 0) {
+      emitMetric(Metric.SKIPPED_SEGMENTS, numSkippedSegments);
+    }
+    datasourceToSummary.forEach(
+        (dataSource, summary) ->
+            emitMetric(dataSource, Metric.PERSISTED_USED_SEGMENTS, summary.usedSegments.size())
+    );
+    emitMetric(Metric.RETRIEVE_SEGMENT_PAYLOADS_DURATION_MILLIS, retrieveDuration.millisElapsed());
+  }
 
-      return updatedCount;
+  /**
+   * Updates the cache of each datasource with the segment payloads fetched from
+   * the metadata store in {@link #retrieveUsedSegmentPayloads}. The update done on
+   * each datasource cache is atomic.
+   */
+  private void updateUsedSegmentPayloadsInCache(
+      Map<String, DatasourceSegmentSummary> datasourceToSummary
+  )
+  {
+    datasourceToSummary.forEach((dataSource, summary) -> {
+      final HeapMemoryDatasourceSegmentCache cache = getCacheForDatasource(dataSource);
+      final int numUpdatedSegments = cache.insertSegments(summary.usedSegments);
+      emitNonZeroMetric(dataSource, Metric.UPDATED_USED_SEGMENTS, numUpdatedSegments);
+    });
+  }
+
+  /**
+   * Updates the cache of each datasource with the pending segments fetched from
+   * the metadata store in {@link #retrieveAllPendingSegments}. The update done on
+   * each datasource cache is atomic.
+   */
+  private void updatePendingSegmentsInCache(
+      Map<String, DatasourceSegmentSummary> datasourceToSummary,
+      DateTime syncStartTime
+  )
+  {
+    datasourceToSummary.forEach((dataSource, summary) -> {
+      final HeapMemoryDatasourceSegmentCache cache = getCacheForDatasource(dataSource);
+      final SegmentSyncResult result = cache.syncPendingSegments(summary.persistedPendingSegments, syncStartTime);
+
+      emitMetric(dataSource, Metric.PERSISTED_PENDING_SEGMENTS, summary.persistedPendingSegments.size());
+      emitNonZeroMetric(dataSource, Metric.UPDATED_PENDING_SEGMENTS, result.getUpdated());
+      emitNonZeroMetric(dataSource, Metric.DELETED_PENDING_SEGMENTS, result.getDeleted());
+    });
+
+    // Update cache for datasources which returned no segments in the latest poll
+    datasourceToSegmentCache.forEach((dataSource, cache) -> {
+      if (!datasourceToSummary.containsKey(dataSource)) {
+        final SegmentSyncResult result = cache.syncPendingSegments(List.of(), syncStartTime);
+        emitNonZeroMetric(dataSource, Metric.DELETED_PENDING_SEGMENTS, result.getDeleted());
+      }
     });
   }
 
   /**
-   * Retrieves all pending segments from metadata store and updates the cache if
-   * {@link HeapMemoryDatasourceSegmentCache#shouldRefreshPendingSegment} is
-   * true for it.
+   * Retrieves all pending segments from metadata store and populates them in
+   * the respective {@link DatasourceSegmentSummary}.
    */
-  private void retrieveAndRefreshAllPendingSegments(
+  private void retrieveAllPendingSegments(
       Map<String, DatasourceSegmentSummary> datasourceToSummary
   )
   {
+    final Stopwatch fetchDuration = Stopwatch.createStarted();
     final String sql = StringUtils.format(
         "SELECT id, dataSource, payload, sequence_name, sequence_prev_id,"
         + " upgraded_from_segment_id, task_allocator_id, created_date FROM %1$s",
@@ -581,21 +689,12 @@ private void retrieveAndRefreshAllPendingSegments(
                 // the rest of the result set cannot be read
                 segmentId = r.getString("id");
                 dataSource = r.getString("dataSource");
-
-                final PendingSegmentRecord record = PendingSegmentRecord.fromResultSet(r, jsonMapper);
-                final HeapMemoryDatasourceSegmentCache cache = getCacheForDatasource(dataSource);
-                final boolean updated = cache.shouldRefreshPendingSegment(record)
-                                        && cache.insertPendingSegment(record, false);
-
-                final DatasourceSegmentSummary summary = datasourceToSummary
-                    .computeIfAbsent(dataSource, ds -> new DatasourceSegmentSummary());
-                if (updated) {
-                  summary.numPendingSegmentsUpdated++;
-                }
-                summary.persistedPendingSegmentIds.add(record.getId().toString());
+                datasourceToSummary
+                    .computeIfAbsent(dataSource, ds -> new DatasourceSegmentSummary())
+                    .addPendingSegmentRecord(PendingSegmentRecord.fromResultSet(r, jsonMapper));
               }
               catch (Exception e) {
-                log.noStackTrace().error(
+                log.error(
                     e,
                     "Error occurred while reading Pending Segment ID[%s] of datasource[%s].",
                     segmentId, dataSource
@@ -607,39 +706,36 @@ private void retrieveAndRefreshAllPendingSegments(
             }).list()
     );
 
+    emitMetric(Metric.RETRIEVE_PENDING_SEGMENTS_DURATION_MILLIS, fetchDuration.millisElapsed());
     if (numSkippedRecords.get() > 0) {
       emitMetric(Metric.SKIPPED_PENDING_SEGMENTS, numSkippedRecords.get());
     }
   }
 
   /**
-   * Removes pending segments from cache if they are not present in the metadata
-   * and were created strictly before the current sync started.
-   */
-  private void removeUnknownPendingSegmentsFromCache(
-      final String dataSource,
-      final DatasourceSegmentSummary summary,
-      final DateTime syncStartTime
-  )
-  {
-    summary.numPendingSegmentsRemoved =
-        getCacheForDatasource(dataSource)
-            .removeUnpersistedPendingSegments(summary.persistedPendingSegmentIds, syncStartTime);
-  }
-
-  /**
-   * Removes segments from the cache if they are not present in the metadata
-   * store and were updated before the latest sync started.
+   * Tries to parse the fields of the result set into a {@link DataSegmentPlus}.
+   *
+   * @return null if an error occurred while parsing the result
    */
-  private void removeUnknownSegmentsFromCache(
-      final String dataSource,
-      final DatasourceSegmentSummary summary,
-      final DateTime syncStartTime
-  )
+  private DataSegmentPlus mapToSegmentPlus(ResultSet resultSet)
   {
-    summary.numSegmentsRemoved =
-        getCacheForDatasource(dataSource)
-            .removeUnpersistedSegments(summary.persistedSegmentIds, syncStartTime);
+    String segmentId = null;
+    try {
+      segmentId = resultSet.getString(1);
+      return new DataSegmentPlus(
+          JacksonUtils.readValue(jsonMapper, resultSet.getBytes(2), DataSegment.class),
+          DateTimes.of(resultSet.getString(3)),
+          DateTimes.of(resultSet.getString(4)),
+          true,
+          null,
+          null,
+          null
+      );
+    }
+    catch (Throwable t) {
+      log.error(t, "Could not read segment with ID[%s]", segmentId);
+      return null;
+    }
   }
 
   private void emitMetric(String metric, long value)
@@ -666,106 +762,26 @@ private void emitMetric(String datasource, String metric, long value)
     );
   }
 
-  @Nullable
-  private static DateTime nullSafeDate(String date)
-  {
-    return date == null ? null : DateTimes.of(date);
-  }
-
-  /**
-   * Represents a single record in the druid_segments table.
-   */
-  private static class SegmentRecord
-  {
-    private final SegmentId segmentId;
-    private final String dataSource;
-    private final boolean isUsed;
-    private final DateTime lastUpdatedTime;
-
-    SegmentRecord(SegmentId segmentId, String dataSource, boolean isUsed, DateTime lastUpdatedTime)
-    {
-      this.segmentId = segmentId;
-      this.dataSource = dataSource;
-      this.isUsed = isUsed;
-      this.lastUpdatedTime = lastUpdatedTime;
-    }
-
-    /**
-     * Creates a SegmentRecord from the given result set.
-     *
-     * @return null if an error occurred while reading the record.
-     */
-    @Nullable
-    static SegmentRecord fromResultSet(ResultSet r)
-    {
-      String serializedId = null;
-      String dataSource = null;
-      try {
-        serializedId = r.getString("id");
-        dataSource = r.getString("dataSource");
-
-        final boolean isUsed = r.getBoolean("used");
-        final DateTime lastUpdatedTime = nullSafeDate(r.getString("used_status_last_updated"));
-
-        final SegmentId segmentId = SegmentId.tryParse(dataSource, serializedId);
-        if (segmentId == null) {
-          log.noStackTrace().error(
-              "Could not parse Segment ID[%s] of datasource[%s]",
-              serializedId, dataSource
-          );
-          return null;
-        } else {
-          return new SegmentRecord(segmentId, dataSource, isUsed, lastUpdatedTime);
-        }
-      }
-      catch (Exception e) {
-        log.noStackTrace().error(
-            e,
-            "Error occurred while reading Segment ID[%s] of datasource[%s]",
-            serializedId, dataSource
-        );
-        return null;
-      }
-    }
-  }
-
   /**
    * Summary of segments currently present in the metadata store for a single
    * datasource.
    */
   private static class DatasourceSegmentSummary
   {
-    final Set<SegmentId> persistedSegmentIds = new HashSet<>();
-    final Set<String> persistedPendingSegmentIds = new HashSet<>();
+    final List<SegmentRecord> persistedSegments = new ArrayList<>();
+    final List<PendingSegmentRecord> persistedPendingSegments = new ArrayList<>();
 
-    final Set<String> usedSegmentIdsToRefresh = new HashSet<>();
-    final Map<Interval, Map<String, Integer>> intervalVersionToMaxUnusedPartition = new HashMap<>();
+    final Set<SegmentId> usedSegmentIdsToRefresh = new HashSet<>();
+    final Set<DataSegmentPlus> usedSegments = new HashSet<>();
 
-    int numPersistedUsedSegments = 0;
-    int numPersistedUnusedSegments = 0;
-    int numUsedSegmentsRefreshed = 0;
-    int numUnusedSegmentsUpdated = 0;
-    int numSegmentsRemoved = 0;
-    int numPendingSegmentsRemoved = 0;
-    int numPendingSegmentsUpdated = 0;
-
-    private boolean isEmpty()
+    private void addSegmentRecord(SegmentRecord record)
     {
-      return persistedPendingSegmentIds.isEmpty() && persistedSegmentIds.isEmpty();
+      persistedSegments.add(record);
     }
 
-    /**
-     * @return true if any of the segments for this datasource have been updated
-     * in the cache in the current sync.
-     */
-    private boolean isCacheUpdated()
+    private void addPendingSegmentRecord(PendingSegmentRecord record)
     {
-      return numSegmentsRemoved > 0
-             || numUsedSegmentsRefreshed > 0
-             || numUnusedSegmentsUpdated > 0
-             || numPendingSegmentsRemoved > 0
-             || numPendingSegmentsUpdated > 0;
+      persistedPendingSegments.add(record);
     }
   }
-
 }
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/cache/Metric.java b/server/src/main/java/org/apache/druid/metadata/segment/cache/Metric.java
index 476b6b1f6aa6..7e5e5485c5d8 100644
--- a/server/src/main/java/org/apache/druid/metadata/segment/cache/Metric.java
+++ b/server/src/main/java/org/apache/druid/metadata/segment/cache/Metric.java
@@ -34,11 +34,6 @@ private Metric()
    */
   public static final String PERSISTED_USED_SEGMENTS = "segment/used/count";
 
-  /**
-   * Total number of segments currently present in the metadata store.
-   */
-  public static final String PERSISTED_UNUSED_SEGMENTS = "segment/unused/count";
-
   /**
    * Total number of pending segments currently present in the metadata store.
    */
@@ -50,13 +45,59 @@ private Metric()
   /**
    * Number of transactions performed on the cache for a datasource.
    */
-  public static final String TRANSACTION_COUNT = "transactions";
+  public static final String TRANSACTION_COUNT = METRIC_NAME_PREFIX + "transactions";
+
+  /**
+   * Total number of distinct intervals currently present in the cache.
+   */
+  public static final String CACHED_INTERVALS = METRIC_NAME_PREFIX + "interval/count";
+
+  /**
+   * Total number of segments currently present in the cache.
+   */
+  public static final String CACHED_USED_SEGMENTS = METRIC_NAME_PREFIX + "used/count";
+
+  /**
+   * Total number of segments currently present in the cache.
+   */
+  public static final String CACHED_UNUSED_SEGMENTS = METRIC_NAME_PREFIX + "unused/count";
+
+  /**
+   * Total number of pending segments currently present in the cache.
+   */
+  public static final String CACHED_PENDING_SEGMENTS = METRIC_NAME_PREFIX + "pending/count";
+
+
+  // CACHE SYNC TIME METRICS
 
   /**
    * Time taken in milliseconds for the latest sync with metadata store.
    */
   public static final String SYNC_DURATION_MILLIS = METRIC_NAME_PREFIX + "sync/time";
 
+  /**
+   * Time taken in milliseconds to update all segment IDs in the cache.
+   */
+  public static final String UPDATE_IDS_DURATION_MILLIS = METRIC_NAME_PREFIX + "updateIds/time";
+
+  /**
+   * Time taken in milliseconds to fetch payloads of used segments from the metadata store.
+   */
+  public static final String RETRIEVE_SEGMENT_PAYLOADS_DURATION_MILLIS = METRIC_NAME_PREFIX + "fetchPayloads/time";
+
+  /**
+   * Time taken in milliseconds to fetch all segment IDs from the metadata store.
+   */
+  public static final String RETRIEVE_SEGMENT_IDS_DURATION_MILLIS = METRIC_NAME_PREFIX + "fetchIds/time";
+
+  /**
+   * Time taken in milliseconds to fetch all pending segments from the metadata store.
+   */
+  public static final String RETRIEVE_PENDING_SEGMENTS_DURATION_MILLIS = METRIC_NAME_PREFIX + "fetchPending/time";
+
+
+  // CACHE UPDATE METRICS
+
   /**
    * Number of segments which are now stale in the cache and need to be refreshed.
    */
@@ -77,11 +118,6 @@ private Metric()
    */
   public static final String UPDATED_USED_SEGMENTS = METRIC_NAME_PREFIX + "used/updated";
 
-  /**
-   * Number of unused segments updated in the cache from the metadata store in the latest sync.
-   */
-  public static final String UPDATED_UNUSED_SEGMENTS = METRIC_NAME_PREFIX + "unused/updated";
-
   /**
    * Number of pending segments updated in the cache from the metadata store in the latest sync.
    */
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/cache/SegmentMetadataCache.java b/server/src/main/java/org/apache/druid/metadata/segment/cache/SegmentMetadataCache.java
index cff12f54635c..af0b17f696f2 100644
--- a/server/src/main/java/org/apache/druid/metadata/segment/cache/SegmentMetadataCache.java
+++ b/server/src/main/java/org/apache/druid/metadata/segment/cache/SegmentMetadataCache.java
@@ -20,7 +20,12 @@
 package org.apache.druid.metadata.segment.cache;
 
 /**
- * Cache for metadata of pending segments and committed segments.
+ * Cache for metadata of pending segments and committed segments maintained by
+ * the Overlord to improve performance of segment allocation and other task actions.
+ * <p>
+ * Not to be confused with {@link org.apache.druid.segment.metadata.AbstractSegmentMetadataCache}
+ * which is used by Brokers to cache row signature, number of rows, etc. to aid
+ * with Druid query performance.
  */
 public interface SegmentMetadataCache
 {
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/cache/SegmentRecord.java b/server/src/main/java/org/apache/druid/metadata/segment/cache/SegmentRecord.java
new file mode 100644
index 000000000000..3b331dc36739
--- /dev/null
+++ b/server/src/main/java/org/apache/druid/metadata/segment/cache/SegmentRecord.java
@@ -0,0 +1,103 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.metadata.segment.cache;
+
+import org.apache.druid.java.util.common.DateTimes;
+import org.apache.druid.java.util.common.logger.Logger;
+import org.apache.druid.timeline.SegmentId;
+import org.joda.time.DateTime;
+
+import javax.annotation.Nullable;
+import java.sql.ResultSet;
+
+/**
+ * Represents a single record in the druid_segments table.
+ */
+class SegmentRecord
+{
+  private static final Logger log = new Logger(SegmentRecord.class);
+
+  private final SegmentId segmentId;
+  private final boolean isUsed;
+  private final DateTime lastUpdatedTime;
+
+  SegmentRecord(SegmentId segmentId, boolean isUsed, DateTime lastUpdatedTime)
+  {
+    this.segmentId = segmentId;
+    this.isUsed = isUsed;
+    this.lastUpdatedTime = lastUpdatedTime;
+  }
+
+  public SegmentId getSegmentId()
+  {
+    return segmentId;
+  }
+
+  public boolean isUsed()
+  {
+    return isUsed;
+  }
+
+  public DateTime getLastUpdatedTime()
+  {
+    return lastUpdatedTime;
+  }
+
+  /**
+   * Creates a SegmentRecord from the given result set.
+   *
+   * @return null if an error occurred while reading the record.
+   */
+  @Nullable
+  static SegmentRecord fromResultSet(ResultSet r)
+  {
+    String serializedId = null;
+    String dataSource = null;
+    try {
+      serializedId = r.getString("id");
+      dataSource = r.getString("dataSource");
+
+      final DateTime lastUpdatedTime = nullSafeDate(r.getString(
+          "used_status_last_updated"));
+
+      final SegmentId segmentId = SegmentId.tryParse(dataSource, serializedId);
+      if (segmentId == null) {
+        log.error("Could not parse Segment ID[%s] of datasource[%s]", serializedId, dataSource);
+        return null;
+      } else {
+        return new SegmentRecord(segmentId, true, lastUpdatedTime);
+      }
+    }
+    catch (Exception e) {
+      log.error(
+          e,
+          "Error occurred while reading Segment ID[%s] of datasource[%s]",
+          serializedId, dataSource
+      );
+      return null;
+    }
+  }
+
+  @Nullable
+  private static DateTime nullSafeDate(String date)
+  {
+    return date == null ? null : DateTimes.of(date);
+  }
+}
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/cache/SegmentSyncResult.java b/server/src/main/java/org/apache/druid/metadata/segment/cache/SegmentSyncResult.java
new file mode 100644
index 000000000000..291444ad748f
--- /dev/null
+++ b/server/src/main/java/org/apache/druid/metadata/segment/cache/SegmentSyncResult.java
@@ -0,0 +1,57 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.metadata.segment.cache;
+
+import org.apache.druid.timeline.SegmentId;
+
+import java.util.Set;
+
+/**
+ * Result of syncing a datasource cache with segments polled from metadata store.
+ */
+public class SegmentSyncResult
+{
+  private final int deleted;
+  private final int updated;
+  private final Set<SegmentId> expiredIds;
+
+  public SegmentSyncResult(int deleted, int updated, Set<SegmentId> expiredIds)
+  {
+    this.deleted = deleted;
+    this.updated = updated;
+    this.expiredIds = expiredIds;
+  }
+
+  public int getDeleted()
+  {
+    return deleted;
+  }
+
+  public int getUpdated()
+  {
+    return updated;
+  }
+
+  public Set<SegmentId> getExpiredIds()
+  {
+    return expiredIds;
+  }
+
+}
diff --git a/server/src/main/java/org/apache/druid/server/http/DataSourcesResource.java b/server/src/main/java/org/apache/druid/server/http/DataSourcesResource.java
index 65d9b3025cd0..5f95a52d1c57 100644
--- a/server/src/main/java/org/apache/druid/server/http/DataSourcesResource.java
+++ b/server/src/main/java/org/apache/druid/server/http/DataSourcesResource.java
@@ -37,8 +37,8 @@
 import org.apache.druid.client.ImmutableSegmentLoadInfo;
 import org.apache.druid.client.SegmentLoadInfo;
 import org.apache.druid.common.guava.FutureUtils;
+import org.apache.druid.common.utils.IdUtils;
 import org.apache.druid.error.DruidException;
-import org.apache.druid.error.InvalidInput;
 import org.apache.druid.guice.annotations.PublicApi;
 import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.java.util.common.Intervals;
@@ -242,18 +242,10 @@ public Response markAsUsedNonOvershadowedSegments(
             return 0;
           }
 
-          // Validate segmentIds
-          final List<String> invalidSegmentIds = new ArrayList<>();
-          for (String segmentId : segmentIds) {
-            if (SegmentId.iteratePossibleParsingsWithDataSource(dataSourceName, segmentId).isEmpty()) {
-              invalidSegmentIds.add(segmentId);
-            }
-          }
-          if (!invalidSegmentIds.isEmpty()) {
-            throw InvalidInput.exception("Could not parse invalid segment IDs[%s]", invalidSegmentIds);
-          }
-
-          return segmentsMetadataManager.markAsUsedNonOvershadowedSegments(dataSourceName, segmentIds);
+          return segmentsMetadataManager.markAsUsedNonOvershadowedSegments(
+              dataSourceName,
+              IdUtils.getValidSegmentIds(dataSourceName, segmentIds)
+          );
         }
       };
 
diff --git a/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java b/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java
index 0212c8f2d998..71e92fc31787 100644
--- a/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java
+++ b/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java
@@ -3331,9 +3331,10 @@ public void testMarkSegmentsAsUnusedWithinIntervalOneYear()
 
     // interval covers existingSegment1 and partially overlaps existingSegment2,
     // only existingSegment1 will be dropped
-    coordinator.markSegmentsAsUnusedWithinInterval(
+    coordinator.markSegmentsWithinIntervalAsUnused(
         existingSegment1.getDataSource(),
-        Intervals.of("1994-01-01/1994-01-02T12Z")
+        Intervals.of("1994-01-01/1994-01-02T12Z"),
+        null
     );
 
     Assert.assertEquals(
@@ -3368,9 +3369,10 @@ public void testMarkSegmentsAsUnusedWithinIntervalTwoYears()
 
     // interval covers existingSegment1 and partially overlaps existingSegment2,
     // only existingSegment1 will be dropped
-    coordinator.markSegmentsAsUnusedWithinInterval(
+    coordinator.markSegmentsWithinIntervalAsUnused(
         existingSegment1.getDataSource(),
-        Intervals.of("1993-12-31T12Z/1994-01-02T12Z")
+        Intervals.of("1993-12-31T12Z/1994-01-02T12Z"),
+        null
     );
 
     Assert.assertEquals(
@@ -3618,7 +3620,7 @@ public void testSegmentIdShouldNotBeReallocated()
     // Clean up pending segments corresponding to the valid task allocator id
     coordinator.deletePendingSegmentsForTaskAllocatorId(TestDataSource.WIKI, "taskAllocatorId");
     // Mark all segments as unused
-    coordinator.markSegmentsAsUnusedWithinInterval(TestDataSource.WIKI, Intervals.ETERNITY);
+    coordinator.markSegmentsWithinIntervalAsUnused(TestDataSource.WIKI, Intervals.ETERNITY, null);
 
     final SegmentIdWithShardSpec theId = allocatePendingSegment(
         TestDataSource.WIKI,
@@ -3659,7 +3661,7 @@ public void testRetrieveUnusedSegmentsForExactIntervalAndVersion()
         ),
         null
     );
-    coordinator.markSegmentsAsUnusedWithinInterval(TestDataSource.WIKI, Intervals.ETERNITY);
+    coordinator.markSegmentsWithinIntervalAsUnused(TestDataSource.WIKI, Intervals.ETERNITY, null);
 
     DataSegment usedSegmentForExactIntervalAndVersion = createSegment(
         Intervals.of("2024/2025"),
@@ -3686,7 +3688,7 @@ public void testRetrieveUpgradedFromSegmentIds()
     final Map<String, String> upgradedFromSegmentIdMap = new HashMap<>();
     upgradedFromSegmentIdMap.put(defaultSegment2.getId().toString(), defaultSegment.getId().toString());
     insertUsedSegments(ImmutableSet.of(defaultSegment, defaultSegment2), upgradedFromSegmentIdMap);
-    coordinator.markSegmentsAsUnusedWithinInterval(datasource, Intervals.ETERNITY);
+    coordinator.markSegmentsWithinIntervalAsUnused(datasource, Intervals.ETERNITY, null);
     upgradedFromSegmentIdMap.clear();
     upgradedFromSegmentIdMap.put(defaultSegment3.getId().toString(), defaultSegment.getId().toString());
     insertUsedSegments(ImmutableSet.of(defaultSegment3, defaultSegment4), upgradedFromSegmentIdMap);
@@ -3755,7 +3757,7 @@ public void testRetrieveUpgradedToSegmentIds()
     final Map<String, String> upgradedFromSegmentIdMap = new HashMap<>();
     upgradedFromSegmentIdMap.put(defaultSegment2.getId().toString(), defaultSegment.getId().toString());
     insertUsedSegments(ImmutableSet.of(defaultSegment, defaultSegment2), upgradedFromSegmentIdMap);
-    coordinator.markSegmentsAsUnusedWithinInterval(datasource, Intervals.ETERNITY);
+    coordinator.markSegmentsWithinIntervalAsUnused(datasource, Intervals.ETERNITY, null);
     upgradedFromSegmentIdMap.clear();
     upgradedFromSegmentIdMap.put(defaultSegment3.getId().toString(), defaultSegment.getId().toString());
     insertUsedSegments(ImmutableSet.of(defaultSegment3, defaultSegment4), upgradedFromSegmentIdMap);
diff --git a/server/src/test/java/org/apache/druid/metadata/SqlSegmentsMetadataManagerTest.java b/server/src/test/java/org/apache/druid/metadata/SqlSegmentsMetadataManagerTest.java
index 70908c29291a..1f71a3513a9e 100644
--- a/server/src/test/java/org/apache/druid/metadata/SqlSegmentsMetadataManagerTest.java
+++ b/server/src/test/java/org/apache/druid/metadata/SqlSegmentsMetadataManagerTest.java
@@ -606,10 +606,10 @@ public void testMarkAsUsedNonOvershadowedSegments() throws Exception
     );
 
     publishUnusedSegments(koalaSegment1, koalaSegment2, koalaSegment3);
-    final Set<String> segmentIds = ImmutableSet.of(
-        koalaSegment1.getId().toString(),
-        koalaSegment2.getId().toString(),
-        koalaSegment3.getId().toString()
+    final Set<SegmentId> segmentIds = ImmutableSet.of(
+        koalaSegment1.getId(),
+        koalaSegment2.getId(),
+        koalaSegment3.getId()
     );
 
     sqlSegmentsMetadataManager.poll();
@@ -887,8 +887,8 @@ public void testMarkAsUsedNonOvershadowedSegmentsInvalidDataSource() throws Exce
     final DataSegment koalaSegment2 = createNewSegment1(TestDataSource.KOALA);
 
     publishUnusedSegments(koalaSegment1, koalaSegment2);
-    final ImmutableSet<String> segmentIds =
-        ImmutableSet.of(koalaSegment1.getId().toString(), koalaSegment2.getId().toString());
+    final ImmutableSet<SegmentId> segmentIds =
+        ImmutableSet.of(koalaSegment1.getId(), koalaSegment2.getId());
     sqlSegmentsMetadataManager.poll();
     Assert.assertEquals(
         ImmutableSet.of(wikiSegment1, wikiSegment2),
@@ -917,8 +917,8 @@ public void testMarkAsUsedNonOvershadowedSegmentsWithInvalidSegmentIds()
     final DataSegment koalaSegment1 = createNewSegment1(TestDataSource.KOALA);
     final DataSegment koalaSegment2 = createNewSegment1(TestDataSource.KOALA);
 
-    final ImmutableSet<String> segmentIds =
-        ImmutableSet.of(koalaSegment1.getId().toString(), koalaSegment2.getId().toString());
+    final ImmutableSet<SegmentId> segmentIds =
+        ImmutableSet.of(koalaSegment1.getId(), koalaSegment2.getId());
     sqlSegmentsMetadataManager.poll();
     Assert.assertEquals(
         ImmutableSet.of(wikiSegment1, wikiSegment2),
diff --git a/server/src/test/java/org/apache/druid/metadata/segment/cache/HeapMemoryDatasourceSegmentCacheTest.java b/server/src/test/java/org/apache/druid/metadata/segment/cache/HeapMemoryDatasourceSegmentCacheTest.java
index 034e33bce552..c78cf31bfdb4 100644
--- a/server/src/test/java/org/apache/druid/metadata/segment/cache/HeapMemoryDatasourceSegmentCacheTest.java
+++ b/server/src/test/java/org/apache/druid/metadata/segment/cache/HeapMemoryDatasourceSegmentCacheTest.java
@@ -43,6 +43,14 @@ public class HeapMemoryDatasourceSegmentCacheTest
 {
   private static final String WIKI = "wiki";
   private static final Interval FIRST_WEEK_OF_JAN = Intervals.of("2024-01-01/P1W");
+  private static final Interval FIRST_DAY_OF_JAN
+      = FIRST_WEEK_OF_JAN.withDurationAfterStart(Duration.standardDays(1));
+  private static final DataSegmentPlus JAN_1_SEGMENT
+      = createUsedSegment().startingAt(FIRST_DAY_OF_JAN.getStart()).withVersion("v1").asPlus();
+  private static final DataSegmentPlus JAN_2_SEGMENT
+      = createUsedSegment().startingAt(FIRST_DAY_OF_JAN.getEnd()).withVersion("v2").asPlus();
+  private static final DataSegmentPlus JAN_3_SEGMENT
+      = createUsedSegment().startingAt(FIRST_DAY_OF_JAN.getEnd().plusDays(1)).withVersion("v3").asPlus();
 
   private HeapMemoryDatasourceSegmentCache cache;
 
@@ -56,8 +64,6 @@ public void setup()
   public void testEmptyCache()
   {
     Assert.assertNull(cache.findUsedSegment(SegmentId.dummy(WIKI)));
-    Assert.assertNull(cache.findHighestUnusedSegmentId(Intervals.ETERNITY, "v1"));
-
     Assert.assertTrue(cache.findUsedSegmentsPlusOverlappingAnyOf(List.of()).isEmpty());
     Assert.assertTrue(cache.findPendingSegmentsOverlapping(Intervals.ETERNITY).isEmpty());
   }
@@ -103,20 +109,28 @@ public void testFindSegmentsWithSchema_throwsUnsupported()
   }
 
   @Test
-  public void testAddSegment_withUsedSegment()
+  public void testFindExistingSegmentIds_throwsUnsupported()
+  {
+    DruidExceptionMatcher.defensive().expectMessageIs(
+        "Unsupported: Unused segments are not cached"
+    ).assertThrowsAndMatches(
+        () -> cache.findExistingSegmentIds(Set.of())
+    );
+  }
+
+  @Test
+  public void testInsertSegments_withUsedSegment()
   {
     final DataSegmentPlus segmentPlus = createUsedSegment().asPlus();
     final DataSegment segment = segmentPlus.getDataSegment();
 
-    cache.addSegment(segmentPlus);
+    cache.insertSegments(Set.of(segmentPlus));
 
     final SegmentId segmentId = segment.getId();
     final Interval interval = segmentId.getInterval();
 
     Assert.assertEquals(segment, cache.findUsedSegment(segmentId));
-    Assert.assertEquals(List.of(segment), cache.findUsedSegments(Set.of(segmentId)));
-
-    Assert.assertEquals(Set.of(segmentId.toString()), cache.findExistingSegmentIds(Set.of(segment)));
+    Assert.assertEquals(List.of(segmentPlus), cache.findUsedSegments(Set.of(segmentId)));
 
     Assert.assertEquals(Set.of(segmentId), cache.findUsedSegmentIdsOverlapping(interval));
     Assert.assertEquals(Set.of(segmentId), cache.findUsedSegmentIdsOverlapping(Intervals.ETERNITY));
@@ -128,41 +142,36 @@ public void testAddSegment_withUsedSegment()
     Assert.assertEquals(Set.of(segmentPlus), cache.findUsedSegmentsPlusOverlappingAnyOf(List.of()));
     Assert.assertEquals(Set.of(segmentPlus), cache.findUsedSegmentsPlusOverlappingAnyOf(List.of(interval)));
     Assert.assertEquals(Set.of(segmentPlus), cache.findUsedSegmentsPlusOverlappingAnyOf(List.of(Intervals.ETERNITY)));
-
-    Assert.assertNull(cache.findHighestUnusedSegmentId(interval, segment.getVersion()));
   }
 
   @Test
-  public void testAddSegment_updatesCacheWithNewerEntry()
+  public void testInsertSegments_updatesCacheWithNewerEntry()
   {
     final DateTime now = DateTimes.nowUtc();
     final DataSegmentPlus segmentPlus = createUsedSegment().lastUpdatedOn(now).asPlus();
-    final DataSegment segment = segmentPlus.getDataSegment();
 
-    Assert.assertTrue(cache.addSegment(segmentPlus));
+    Assert.assertEquals(1, cache.insertSegments(Set.of(segmentPlus)));
     Assert.assertEquals(Set.of(segmentPlus), cache.findUsedSegmentsPlusOverlappingAnyOf(List.of()));
 
     // Verify that a segment with older updated time does not update cache
-    final DataSegmentPlus oldSegmentPlus
-        = new DataSegmentPlus(segment, null, now.minus(1), true, null, 100L, null);
-    Assert.assertFalse(cache.addSegment(oldSegmentPlus));
+    final DataSegmentPlus oldSegmentPlus = updateSegment(segmentPlus, now.minus(1));
+    Assert.assertEquals(0, cache.insertSegments(Set.of(oldSegmentPlus)));
     Assert.assertEquals(Set.of(segmentPlus), cache.findUsedSegmentsPlusOverlappingAnyOf(List.of()));
 
     // Verify that a segment with newer updated time updates the cache
-    final DataSegmentPlus newSegmentPlus
-        = new DataSegmentPlus(segment, null, now.plus(1), true, null, 100L, null);
-    Assert.assertTrue(cache.addSegment(newSegmentPlus));
+    final DataSegmentPlus newSegmentPlus = updateSegment(segmentPlus, now.plus(1));
+    Assert.assertEquals(1, cache.insertSegments(Set.of(newSegmentPlus)));
     Assert.assertEquals(Set.of(newSegmentPlus), cache.findUsedSegmentsPlusOverlappingAnyOf(List.of()));
   }
 
   @Test
-  public void testAddSegment_withUnusedSegment()
+  public void testInsertSegments_withUnusedSegment()
   {
     final DataSegmentPlus segmentPlus = createUnusedSegment().asPlus();
     final DataSegment segment = segmentPlus.getDataSegment();
     final SegmentId segmentId = segment.getId();
 
-    cache.addSegment(segmentPlus);
+    cache.insertSegments(Set.of(segmentPlus));
 
     // Verify that the segment is not returned in any of the used segment methods
     Assert.assertNull(cache.findUsedSegment(segmentId));
@@ -171,80 +180,37 @@ public void testAddSegment_withUnusedSegment()
     Assert.assertTrue(cache.findUsedSegmentsOverlappingAnyOf(List.of()).isEmpty());
     Assert.assertTrue(cache.findUsedSegmentsPlusOverlappingAnyOf(List.of()).isEmpty());
 
-    Assert.assertEquals(Set.of(segmentId.toString()), cache.findExistingSegmentIds(Set.of(segment)));
-
-    // Verify unused segment methods
-    Assert.assertEquals(segmentId, cache.findHighestUnusedSegmentId(segment.getInterval(), segment.getVersion()));
+    final CacheStats cacheStats = cache.markCacheSynced();
+    Assert.assertEquals(0, cacheStats.getNumUsedSegments());
+    Assert.assertEquals(1, cacheStats.getNumUnusedSegments());
   }
 
   @Test
-  public void testShouldRefreshUsedSegment_returnsTrueIfCacheHasNoEntry()
+  public void testInsertSegments_addsToCache_ifUpdatedTimeIsNull()
   {
-    final SegmentId segmentId = SegmentId.dummy(WIKI);
-    Assert.assertTrue(cache.shouldRefreshUsedSegment(segmentId, null));
-    Assert.assertTrue(cache.shouldRefreshUsedSegment(segmentId, DateTimes.EPOCH));
-    Assert.assertTrue(cache.shouldRefreshUsedSegment(segmentId, DateTimes.nowUtc()));
+    final DataSegmentPlus usedSegmentPlus = createUsedSegment().lastUpdatedOn(null).asPlus();
+    Assert.assertEquals(1, cache.insertSegments(Set.of(usedSegmentPlus)));
+    Assert.assertEquals(Set.of(usedSegmentPlus), cache.findUsedSegmentsPlusOverlappingAnyOf(List.of()));
   }
 
   @Test
-  public void testShouldRefreshUsedSegment_returnsTrueIfCacheHasOutdatedEntry()
+  public void testInsertSegments_doesNotUpdateCache_ifNewUpdatedTimeIsNull()
   {
-    final DataSegmentPlus segmentPlus = createUsedSegment().updatedNow().asPlus();
-    final DataSegment segment = segmentPlus.getDataSegment();
-    final SegmentId segmentId = segment.getId();
-
-    cache.addSegment(segmentPlus);
-    Assert.assertEquals(segment, cache.findUsedSegment(segmentId));
-
-    final DateTime cachedUpdatedTime = segmentPlus.getUsedStatusLastUpdatedDate();
-    Assert.assertNotNull(cachedUpdatedTime);
-
-    // Verify that segment refresh is required only if updated time has increased
-    Assert.assertFalse(cache.shouldRefreshUsedSegment(segmentId, null));
-    Assert.assertFalse(cache.shouldRefreshUsedSegment(segmentId, cachedUpdatedTime));
-    Assert.assertFalse(cache.shouldRefreshUsedSegment(segmentId, cachedUpdatedTime.minus(1)));
-
-    Assert.assertTrue(cache.shouldRefreshUsedSegment(segmentId, cachedUpdatedTime.plus(1)));
+    final DataSegmentPlus usedSegment = createUsedSegment().lastUpdatedOn(null).asPlus();
+    Assert.assertEquals(1, cache.insertSegments(Set.of(usedSegment)));
+    Assert.assertEquals(0, cache.insertSegments(Set.of(updateSegment(usedSegment, null))));
   }
 
   @Test
-  public void testAddSegment_canMarkItAsUsed()
-  {
-    final DataSegmentPlus usedSegmentPlus = createUsedSegment().asPlus();
-    final DataSegment segment = usedSegmentPlus.getDataSegment();
-    final SegmentId segmentId = segment.getId();
-
-    cache.addSegment(usedSegmentPlus);
-
-    Assert.assertEquals(segment, cache.findUsedSegment(segmentId));
-    Assert.assertNull(cache.findHighestUnusedSegmentId(segment.getInterval(), segment.getVersion()));
-
-    final DataSegmentPlus unusedSegmentPlus = new DataSegmentPlus(
-        segment,
-        null,
-        DateTimes.EPOCH,
-        false,
-        null,
-        null,
-        null
-    );
-
-    cache.addSegment(unusedSegmentPlus);
-
-    Assert.assertNull(cache.findUsedSegment(segmentId));
-    Assert.assertEquals(segmentId, cache.findHighestUnusedSegmentId(segment.getInterval(), segment.getVersion()));
-  }
-
-  @Test
-  public void testAddSegment_canMarkItAsUnused()
+  public void testInsertSegments_canMarkItAsUnused()
   {
     final DataSegmentPlus unusedSegmentPlus = createUnusedSegment().asPlus();
     final DataSegment segment = unusedSegmentPlus.getDataSegment();
     final SegmentId segmentId = segment.getId();
 
-    cache.addSegment(unusedSegmentPlus);
+    cache.insertSegments(Set.of(unusedSegmentPlus));
 
-    Assert.assertEquals(segmentId, cache.findHighestUnusedSegmentId(segment.getInterval(), segment.getVersion()));
+    // TODO: Assert.assertEquals(segmentId, cache.findHighestUnusedSegmentId(segment.getInterval(), segment.getVersion()));
     Assert.assertNull(cache.findUsedSegment(segmentId));
 
     final DataSegmentPlus usedSegmentPlus = new DataSegmentPlus(
@@ -257,90 +223,33 @@ public void testAddSegment_canMarkItAsUnused()
         null
     );
 
-    cache.addSegment(usedSegmentPlus);
+    cache.insertSegments(Set.of(usedSegmentPlus));
 
     Assert.assertEquals(segment, cache.findUsedSegment(segmentId));
   }
 
   @Test
-  public void testAddUnusedSegmentId()
-  {
-    final DataSegmentPlus unusedSegmentPlus = createUnusedSegment().asPlus();
-    final DataSegment segment = unusedSegmentPlus.getDataSegment();
-    final SegmentId segmentId = segment.getId();
-
-    Assert.assertTrue(cache.addUnusedSegmentId(segmentId, null));
-
-    Assert.assertEquals(Set.of(segmentId.toString()), cache.findExistingSegmentIds(Set.of(segment)));
-    Assert.assertEquals(segmentId, cache.findHighestUnusedSegmentId(segment.getInterval(), segment.getVersion()));
-  }
-
-  @Test
-  public void testAddUnusedSegmentId_updatesCacheWithNewerEntry()
+  public void testSyncSegmentIds_identifiesExpiredUsedSegmentIds()
   {
-    final DataSegmentPlus unusedSegmentPlus = createUnusedSegment().asPlus();
-    final DataSegment segment = unusedSegmentPlus.getDataSegment();
-    final SegmentId segmentId = segment.getId();
-
-    Assert.assertTrue(cache.addUnusedSegmentId(segmentId, null));
-
-    Assert.assertFalse(cache.addUnusedSegmentId(segmentId, null));
+    final DataSegmentPlus usedSegmentPlus = createUsedSegment().updatedNow().asPlus();
+    final SegmentRecord usedRecord = asRecord(usedSegmentPlus);
 
     final DateTime now = DateTimes.nowUtc();
-    Assert.assertTrue(cache.addUnusedSegmentId(segmentId, now));
-
-    Assert.assertFalse(cache.addUnusedSegmentId(segmentId, null));
-    Assert.assertFalse(cache.addUnusedSegmentId(segmentId, now.minus(1)));
-
-    Assert.assertTrue(cache.addUnusedSegmentId(segmentId, now.plus(1)));
+    SegmentSyncResult result = cache.syncSegmentIds(List.of(usedRecord), now);
+    Assert.assertEquals(Set.of(usedRecord.getSegmentId()), result.getExpiredIds());
   }
 
   @Test
-  public void testAddUnusedSegmenId_marksUsedSegmentAsUnused()
+  public void testSyncSegmentIds_ignoresUnusedSegment()
   {
-    final DataSegmentPlus usedSegmentPlus = createUsedSegment().asPlus();
-    final DataSegment segment = usedSegmentPlus.getDataSegment();
-    final SegmentId segmentId = segment.getId();
-
-    cache.addSegment(usedSegmentPlus);
-    Assert.assertEquals(segment, cache.findUsedSegment(segmentId));
-    Assert.assertNull(cache.findHighestUnusedSegmentId(segment.getInterval(), segment.getVersion()));
-
-    cache.addUnusedSegmentId(segmentId, null);
-    Assert.assertNull(cache.findUsedSegment(segmentId));
-    Assert.assertEquals(segmentId, cache.findHighestUnusedSegmentId(segment.getInterval(), segment.getVersion()));
-  }
-
-  @Test
-  public void testMarkCacheSynced_isNeededAfterUpdateOrRemove()
-  {
-    final DataSegmentPlus unusedSegmentPlus = createUnusedSegment().asPlus();
-    final DataSegment segment = unusedSegmentPlus.getDataSegment();
-    final SegmentId segmentId = segment.getId();
-
-    cache.addSegment(unusedSegmentPlus);
-    Assert.assertEquals(segmentId, cache.findHighestUnusedSegmentId(segment.getInterval(), segment.getVersion()));
-
-    // Verify that marking the segment as used does not update the highest ID
-    final DataSegmentPlus usedSegmentPlus = new DataSegmentPlus(
-        segment,
-        null,
-        DateTimes.EPOCH,
-        true,
-        null,
-        null,
-        null
-    );
-    cache.addSegment(usedSegmentPlus);
-    Assert.assertEquals(segmentId, cache.findHighestUnusedSegmentId(segment.getInterval(), segment.getVersion()));
+    final DataSegmentPlus unusedSegmentPlus = createUnusedSegment().updatedNow().asPlus();
+    final SegmentRecord unusedRecord = asRecord(unusedSegmentPlus);
 
-    // Verify that removing segment does not update the highest ID
-    cache.removeSegmentsForIds(Set.of(segmentId));
-    Assert.assertEquals(segmentId, cache.findHighestUnusedSegmentId(segment.getInterval(), segment.getVersion()));
-
-    // Verify that only reset updates the highest ID
-    cache.markCacheSynced();
-    Assert.assertNull(cache.findHighestUnusedSegmentId(segment.getInterval(), segment.getVersion()));
+    final DateTime now = DateTimes.nowUtc();
+    SegmentSyncResult result = cache.syncSegmentIds(List.of(unusedRecord), now);
+    Assert.assertEquals(0, result.getUpdated());
+    Assert.assertEquals(0, result.getDeleted());
+    Assert.assertTrue(result.getExpiredIds().isEmpty());
   }
 
   @Test
@@ -440,7 +349,7 @@ public void testInsertPendingSegments()
   }
 
   @Test
-  public void testShouldRefreshPendingSegment_returnsTrueWhenNotPresentInCache()
+  public void testInsertPendingSegment_isIdempotent()
   {
     final PendingSegmentRecord pendingSegment = PendingSegmentRecord.create(
         new SegmentIdWithShardSpec(WIKI, Intervals.ETERNITY, "v1", new NumberedShardSpec(0, 1)),
@@ -449,13 +358,13 @@ public void testShouldRefreshPendingSegment_returnsTrueWhenNotPresentInCache()
         null,
         null
     );
-    Assert.assertTrue(cache.shouldRefreshPendingSegment(pendingSegment));
     Assert.assertTrue(cache.insertPendingSegment(pendingSegment, true));
-    Assert.assertFalse(cache.shouldRefreshPendingSegment(pendingSegment));
+    Assert.assertFalse(cache.insertPendingSegment(pendingSegment, true));
+    Assert.assertEquals(List.of(pendingSegment), cache.findPendingSegmentsOverlapping(Intervals.ETERNITY));
   }
 
   @Test
-  public void testRemoveUnpersistedSegments_removesUsedSegmentUpdatedBeforeSyncStart()
+  public void testSyncSegmentIds_removesUsedSegmentUpdatedBeforeSyncStart()
   {
     final DateTime syncTime = DateTimes.nowUtc();
 
@@ -478,9 +387,9 @@ public void testRemoveUnpersistedSegments_removesUsedSegmentUpdatedBeforeSyncSta
     );
 
     // Remove unpersisted segments and verify that only unpersisted segments
-    // last updated before the sync time are remove
-    cache.removeUnpersistedSegments(
-        Set.of(persistedSegment.getDataSegment().getId()),
+    // last updated before the sync time are removed
+    cache.syncSegmentIds(
+        List.of(asRecord(persistedSegment)),
         syncTime
     );
     Assert.assertEquals(
@@ -490,62 +399,43 @@ public void testRemoveUnpersistedSegments_removesUsedSegmentUpdatedBeforeSyncSta
   }
 
   @Test
-  public void testRemoveUnpersistedSegments_removesUnusedSegmentUpdatedBeforeSyncStart()
+  public void testSyncSegmentIds_removesUnusedSegmentUpdatedBeforeSyncStart()
   {
     final DateTime syncTime = DateTimes.nowUtc();
 
-    final DataSegmentPlus persistedSegment = createUnusedSegment().asPlus();
-    final DataSegmentPlus unpersistedSegmentUpdatedBeforeSync =
+    final DataSegmentPlus usedSegment = createUsedSegment().asPlus();
+    final DataSegmentPlus unusedSegmentUpdatedBeforeSync =
         createUnusedSegment().lastUpdatedOn(syncTime.minus(1)).asPlus();
-    final DataSegmentPlus unpersistedSegmentUpdatedAfterSync =
+    final DataSegmentPlus unusedSegmentUpdatedAfterSync =
         createUnusedSegment().lastUpdatedOn(syncTime.plus(1)).asPlus();
 
     // Add unused segments to the cache and verify that they have been added
     cache.insertSegments(
         Set.of(
-            persistedSegment,
-            unpersistedSegmentUpdatedBeforeSync,
-            unpersistedSegmentUpdatedAfterSync
-        )
-    );
-    Assert.assertEquals(
-        Set.of(
-            persistedSegment.getDataSegment().getId().toString(),
-            unpersistedSegmentUpdatedBeforeSync.getDataSegment().getId().toString(),
-            unpersistedSegmentUpdatedAfterSync.getDataSegment().getId().toString()
-        ),
-        cache.findExistingSegmentIds(
-            Set.of(
-                persistedSegment.getDataSegment(),
-                unpersistedSegmentUpdatedBeforeSync.getDataSegment(),
-                unpersistedSegmentUpdatedAfterSync.getDataSegment()
-            )
+            usedSegment,
+            unusedSegmentUpdatedBeforeSync,
+            unusedSegmentUpdatedAfterSync
         )
     );
 
+    CacheStats cacheStats = cache.markCacheSynced();
+    Assert.assertEquals(1, cacheStats.getNumUsedSegments());
+    Assert.assertEquals(2, cacheStats.getNumUnusedSegments());
+
     // Remove unpersisted segments and verify that only unpersisted segments
-    // last updated before the sync time are remove
-    cache.removeUnpersistedSegments(
-        Set.of(persistedSegment.getDataSegment().getId()),
+    // last updated before the sync time are removed
+    cache.syncSegmentIds(
+        List.of(asRecord(usedSegment)),
         syncTime
     );
-    Assert.assertEquals(
-        Set.of(
-            persistedSegment.getDataSegment().getId().toString(),
-            unpersistedSegmentUpdatedAfterSync.getDataSegment().getId().toString()
-        ),
-        cache.findExistingSegmentIds(
-            Set.of(
-                persistedSegment.getDataSegment(),
-                unpersistedSegmentUpdatedBeforeSync.getDataSegment(),
-                unpersistedSegmentUpdatedAfterSync.getDataSegment()
-            )
-        )
-    );
+
+    cacheStats = cache.markCacheSynced();
+    Assert.assertEquals(1, cacheStats.getNumUsedSegments());
+    Assert.assertEquals(1, cacheStats.getNumUnusedSegments());
   }
 
   @Test
-  public void testRemoveUnpersistedPendingSegments_removesPendingSegmentCreatedbeforeSyncStart()
+  public void testSyncPendingSegments_removesPendingSegmentCreatedbeforeSyncStart()
   {
     final DateTime syncTime = DateTimes.nowUtc();
     final String taskAllocator = "allocator1";
@@ -588,8 +478,8 @@ public void testRemoveUnpersistedPendingSegments_removesPendingSegmentCreatedbef
 
     // Remove unpersisted segments and verify that only segments which are not
     // present in the metadata store and were created before the sync are removed
-    cache.removeUnpersistedPendingSegments(
-        Set.of(persistedSegment.getId().toString()),
+    cache.syncPendingSegments(
+        List.of(persistedSegment),
         syncTime
     );
     Assert.assertEquals(
@@ -602,28 +492,31 @@ public void testRemoveUnpersistedPendingSegments_removesPendingSegmentCreatedbef
   public void testDeleteSegments()
   {
     final DataSegmentPlus usedSegmentPlus = createUsedSegment().asPlus();
-    final String usedSegmentId = usedSegmentPlus.getDataSegment().getId().toString();
+    final SegmentId usedSegmentId = usedSegmentPlus.getDataSegment().getId();
 
     final DataSegmentPlus unusedSegmentPlus = createUnusedSegment().withVersion("v1").asPlus();
-    final String unusedSegmentId = unusedSegmentPlus.getDataSegment().getId().toString();
+    final SegmentId unusedSegmentId = unusedSegmentPlus.getDataSegment().getId();
 
-    cache.addSegment(usedSegmentPlus);
-    cache.addSegment(unusedSegmentPlus);
+    cache.insertSegments(Set.of(usedSegmentPlus, unusedSegmentPlus));
     Assert.assertEquals(
-        Set.of(usedSegmentId, unusedSegmentId),
-        cache.findExistingSegmentIds(Set.of(usedSegmentPlus.getDataSegment(), unusedSegmentPlus.getDataSegment()))
+        List.of(usedSegmentPlus),
+        cache.findUsedSegments(Set.of(usedSegmentId))
     );
 
+    CacheStats cacheStats = cache.markCacheSynced();
+    Assert.assertEquals(1, cacheStats.getNumUsedSegments());
+    Assert.assertEquals(1, cacheStats.getNumUnusedSegments());
+    Assert.assertFalse(cache.isEmpty());
+
     Assert.assertEquals(
         2,
-        cache.deleteSegments(
-            Set.of(usedSegmentPlus.getDataSegment().getId(), unusedSegmentPlus.getDataSegment().getId())
-        )
-    );
-    Assert.assertTrue(
-        cache.findExistingSegmentIds(Set.of(usedSegmentPlus.getDataSegment(), unusedSegmentPlus.getDataSegment()))
-             .isEmpty()
+        cache.deleteSegments(Set.of(usedSegmentId, unusedSegmentId))
     );
+
+    cacheStats = cache.markCacheSynced();
+    Assert.assertEquals(0, cacheStats.getNumUsedSegments());
+    Assert.assertEquals(0, cacheStats.getNumUnusedSegments());
+    Assert.assertTrue(cache.isEmpty());
   }
 
   @Test
@@ -772,25 +665,28 @@ public void testDeletePendingSegmentsCreatedIn()
   @Test
   public void testMarkSegmentsWithinIntervalAsUnused()
   {
-    final Interval firstDayOfJan = FIRST_WEEK_OF_JAN.withDurationAfterStart(Duration.standardDays(1));
-    final DataSegmentPlus jan1Segment
-        = createUsedSegment().startingAt(firstDayOfJan.getStart()).asPlus();
-    final DataSegmentPlus jan2Segment
-        = createUsedSegment().startingAt(firstDayOfJan.getEnd()).asPlus();
-    final DataSegmentPlus jan3Segment
-        = createUsedSegment().startingAt(firstDayOfJan.getEnd().plusDays(1)).asPlus();
-
-    cache.insertSegments(Set.of(jan1Segment, jan2Segment, jan3Segment));
+    cache.insertSegments(Set.of(JAN_1_SEGMENT, JAN_2_SEGMENT, JAN_3_SEGMENT));
     Assert.assertEquals(
-        Set.of(jan1Segment, jan2Segment, jan3Segment),
+        Set.of(JAN_1_SEGMENT, JAN_2_SEGMENT, JAN_3_SEGMENT),
         cache.findUsedSegmentsPlusOverlappingAnyOf(List.of(FIRST_WEEK_OF_JAN))
     );
 
-    // Mark segments as unused
+    // Mark segments as unused by interval
     Assert.assertEquals(
-        2,
+        1,
         cache.markSegmentsWithinIntervalAsUnused(
-            firstDayOfJan.withDurationAfterStart(Duration.standardDays(2)),
+            FIRST_DAY_OF_JAN.withDurationAfterStart(Duration.standardDays(1)),
+            null,
+            DateTimes.nowUtc()
+        )
+    );
+
+    // Mark segment as unused by version
+    Assert.assertEquals(
+        1,
+        cache.markSegmentsWithinIntervalAsUnused(
+            Intervals.ETERNITY,
+            List.of(JAN_2_SEGMENT.getDataSegment().getVersion()),
             DateTimes.nowUtc()
         )
     );
@@ -798,22 +694,51 @@ public void testMarkSegmentsWithinIntervalAsUnused()
     // Verify that all the segment IDs are still present in cache but 2 have
     // been marked as unused
     Assert.assertEquals(
-        Set.of(jan3Segment),
+        Set.of(JAN_3_SEGMENT),
         cache.findUsedSegmentsPlusOverlappingAnyOf(List.of(FIRST_WEEK_OF_JAN))
     );
+
+    final CacheStats cacheStats = cache.markCacheSynced();
+    Assert.assertEquals(1, cacheStats.getNumUsedSegments());
+    Assert.assertEquals(2, cacheStats.getNumUnusedSegments());
+    Assert.assertEquals(3, cacheStats.getNumIntervals());
+  }
+
+  @Test
+  public void testMarkSegmentAsUnused()
+  {
+    cache.insertSegments(Set.of(JAN_1_SEGMENT, JAN_2_SEGMENT, JAN_3_SEGMENT));
+
+    cache.markSegmentAsUnused(JAN_1_SEGMENT.getDataSegment().getId(), DateTimes.nowUtc());
     Assert.assertEquals(
-        Set.of(
-            jan1Segment.getDataSegment().getId().toString(),
-            jan2Segment.getDataSegment().getId().toString(),
-            jan3Segment.getDataSegment().getId().toString()
-        ),
-        cache.findExistingSegmentIds(
-            Set.of(
-                jan1Segment.getDataSegment(),
-                jan2Segment.getDataSegment(),
-                jan3Segment.getDataSegment()
-            )
-        )
+        Set.of(JAN_2_SEGMENT, JAN_3_SEGMENT),
+        cache.findUsedSegmentsPlusOverlappingAnyOf(List.of(FIRST_WEEK_OF_JAN))
+    );
+  }
+
+  @Test
+  public void testMarkSegmentsAsUnused()
+  {
+    cache.insertSegments(Set.of(JAN_1_SEGMENT, JAN_2_SEGMENT, JAN_3_SEGMENT));
+
+    cache.markSegmentsAsUnused(
+        Set.of(JAN_1_SEGMENT.getDataSegment().getId(), JAN_2_SEGMENT.getDataSegment().getId()),
+        DateTimes.nowUtc()
+    );
+    Assert.assertEquals(
+        Set.of(JAN_3_SEGMENT),
+        cache.findUsedSegmentsPlusOverlappingAnyOf(List.of(FIRST_WEEK_OF_JAN))
+    );
+  }
+
+  @Test
+  public void testMarkAllSegmentsAsUnused()
+  {
+    cache.insertSegments(Set.of(JAN_1_SEGMENT, JAN_2_SEGMENT, JAN_3_SEGMENT));
+    cache.markAllSegmentsAsUnused(DateTimes.nowUtc());
+    Assert.assertTrue(
+        cache.findUsedSegmentsPlusOverlappingAnyOf(List.of(FIRST_WEEK_OF_JAN))
+             .isEmpty()
     );
   }
 
@@ -844,4 +769,26 @@ private static CreateDataSegments createUnusedSegment()
   {
     return CreateDataSegments.ofDatasource(WIKI).markUnused();
   }
+
+  private static DataSegmentPlus updateSegment(DataSegmentPlus segment, DateTime newUpdatedTime)
+  {
+    return new DataSegmentPlus(
+        segment.getDataSegment(),
+        segment.getCreatedDate(),
+        newUpdatedTime,
+        segment.getUsed(),
+        segment.getSchemaFingerprint(),
+        segment.getNumRows(),
+        segment.getUpgradedFromSegmentId()
+    );
+  }
+
+  private static SegmentRecord asRecord(DataSegmentPlus segment)
+  {
+    return new SegmentRecord(
+        segment.getDataSegment().getId(),
+        Boolean.TRUE.equals(segment.getUsed()),
+        segment.getUsedStatusLastUpdatedDate()
+    );
+  }
 }
diff --git a/server/src/test/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCacheTest.java b/server/src/test/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCacheTest.java
index 0b6cf606f44a..16710fef591f 100644
--- a/server/src/test/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCacheTest.java
+++ b/server/src/test/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCacheTest.java
@@ -50,6 +50,7 @@
 import org.junit.Rule;
 import org.junit.Test;
 
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -318,32 +319,6 @@ public void testSync_addsUsedSegment_ifNotPresentInCache()
     );
   }
 
-  @Test
-  public void testSync_addsUnusedSegment_ifNotPresentInCache()
-  {
-    setupAndSyncCache();
-
-    final DataSegmentPlus unusedSegmentPlus
-        = CreateDataSegments.ofDatasource(TestDataSource.WIKI).updatedNow().markUnused().asPlus();
-    insertSegmentsInMetadataStore(Set.of(unusedSegmentPlus));
-
-    final SegmentId segmentId = unusedSegmentPlus.getDataSegment().getId();
-
-    final DatasourceSegmentCache wikiCache = cache.getDatasource(TestDataSource.WIKI);
-    Assert.assertNull(
-        wikiCache.findHighestUnusedSegmentId(segmentId.getInterval(), segmentId.getVersion())
-    );
-
-    syncCache();
-    serviceEmitter.verifyValue(Metric.UPDATED_UNUSED_SEGMENTS, 1L);
-    serviceEmitter.verifyValue(Metric.PERSISTED_UNUSED_SEGMENTS, 1L);
-
-    Assert.assertEquals(
-        segmentId,
-        wikiCache.findHighestUnusedSegmentId(segmentId.getInterval(), segmentId.getVersion())
-    );
-  }
-
   @Test
   public void testSync_emitsAlert_ifErrorOccurs()
   {
@@ -376,9 +351,10 @@ public void testSync_doesNotFail_ifSegmentRecordIsBad()
                                                              .updatedNow().markUsed().asPlus();
     insertSegmentsInMetadataStore(Set.of(validSegment, invalidSegment));
 
-    // Update the second segment to have an invalid payload
+    // Update the second segment to have an invalid id and payload
     derbyConnectorRule.segments().update(
-        "UPDATE %1$s SET id = 'invalid' WHERE id = ?",
+        "UPDATE %1$s SET id = 'invalid', payload = ? WHERE id = ?",
+        "invalid".getBytes(StandardCharsets.UTF_8),
         invalidSegment.getDataSegment().getId().toString()
     );
 
@@ -467,7 +443,7 @@ public void testSync_updatesUsedSegment_ifCacheHasOlderEntry()
     // Add a newer version of segment to metadata store
     final DataSegmentPlus updatedSegment = new DataSegmentPlus(
         usedSegmentPlus.getDataSegment(),
-        null,
+        usedSegmentPlus.getCreatedDate(),
         updateTime.plus(1),
         true,
         null,
@@ -487,27 +463,6 @@ public void testSync_updatesUsedSegment_ifCacheHasOlderEntry()
     );
   }
 
-  @Test
-  public void testSync_updatesUnusedSegment_ifCacheHasOlderEntry()
-  {
-    setupAndSyncCache();
-    final DatasourceSegmentCache wikiCache = cache.getDatasource(TestDataSource.WIKI);
-
-    final DataSegmentPlus unusedSegment =
-        CreateDataSegments.ofDatasource(TestDataSource.WIKI).updatedNow().markUnused().asPlus();
-    insertSegmentsInMetadataStore(Set.of(unusedSegment));
-
-    syncCache();
-    serviceEmitter.verifyValue(Metric.PERSISTED_UNUSED_SEGMENTS, 1L);
-    serviceEmitter.verifyValue(Metric.UPDATED_UNUSED_SEGMENTS, 1L);
-
-    final SegmentId segmentId = unusedSegment.getDataSegment().getId();
-    Assert.assertEquals(
-        segmentId,
-        wikiCache.findHighestUnusedSegmentId(segmentId.getInterval(), segmentId.getVersion())
-    );
-  }
-
   @Test
   public void testSync_removesUsedSegment_ifNotPresentInMetadataStore()
   {
@@ -526,7 +481,7 @@ public void testSync_removesUsedSegment_ifNotPresentInMetadataStore()
 
     syncCache();
     serviceEmitter.verifyValue(Metric.DELETED_SEGMENTS, 1L);
-    serviceEmitter.verifyValue(Metric.PERSISTED_USED_SEGMENTS, 0L);
+    serviceEmitter.verifyNotEmitted(Metric.PERSISTED_USED_SEGMENTS);
 
     Assert.assertNull(
         wikiCache.findUsedSegment(unpersistedSegment.getId())
@@ -534,34 +489,46 @@ public void testSync_removesUsedSegment_ifNotPresentInMetadataStore()
   }
 
   @Test
-  public void testSync_removesUnusedSegment_ifNotPresentInMetadataStore()
+  public void testSync_removesUnusedSegment_ifCacheHasOlderEntry()
   {
     setupAndSyncCache();
     final DatasourceSegmentCache wikiCache = cache.getDatasource(TestDataSource.WIKI);
 
+    final DateTime now = DateTimes.nowUtc();
     final DataSegmentPlus unpersistedSegmentPlus =
-        CreateDataSegments.ofDatasource(TestDataSource.WIKI).markUnused().asPlus();
+        CreateDataSegments.ofDatasource(TestDataSource.WIKI).markUsed().asPlus();
     wikiCache.insertSegments(Set.of(unpersistedSegmentPlus));
-
-    final SegmentId unusedSegmentId = unpersistedSegmentPlus.getDataSegment().getId();
-    Assert.assertEquals(
-        unusedSegmentId,
-        wikiCache.findHighestUnusedSegmentId(
-            unusedSegmentId.getInterval(),
-            unusedSegmentId.getVersion()
-        )
-    );
+    wikiCache.markSegmentAsUnused(unpersistedSegmentPlus.getDataSegment().getId(), now.minusMinutes(1));
 
     syncCache();
     serviceEmitter.verifyValue(Metric.DELETED_SEGMENTS, 1L);
-    serviceEmitter.verifyValue(Metric.PERSISTED_USED_SEGMENTS, 0L);
+    serviceEmitter.verifyNotEmitted(Metric.PERSISTED_USED_SEGMENTS);
+    serviceEmitter.verifyNotEmitted(Metric.CACHED_USED_SEGMENTS);
+    serviceEmitter.verifyNotEmitted(Metric.CACHED_UNUSED_SEGMENTS);
+  }
 
-    Assert.assertNull(
-        wikiCache.findHighestUnusedSegmentId(
-            unusedSegmentId.getInterval(),
-            unusedSegmentId.getVersion()
-        )
-    );
+  @Test
+  public void testSync_doesNotRemoveIntervalWithOnlyUnusedSegments()
+  {
+    setupAndSyncCache();
+
+    final DataSegmentPlus usedSegment =
+        CreateDataSegments.ofDatasource(TestDataSource.WIKI).updatedNow().markUsed().asPlus();
+
+    final DateTime now = DateTimes.nowUtc();
+    final DatasourceSegmentCache wikiCache = cache.getDatasource(TestDataSource.WIKI);
+    wikiCache.insertSegments(Set.of(usedSegment));
+    wikiCache.markSegmentAsUnused(usedSegment.getDataSegment().getId(), now.plusMinutes(1));
+
+    syncCache();
+    serviceEmitter.verifyValue(Metric.CACHED_UNUSED_SEGMENTS, 1L);
+    serviceEmitter.verifyValue(Metric.CACHED_INTERVALS, 1L);
+
+    // Perform another sync
+    serviceEmitter.flush();
+    syncCache();
+    serviceEmitter.verifyValue(Metric.CACHED_UNUSED_SEGMENTS, 1L);
+    serviceEmitter.verifyValue(Metric.CACHED_INTERVALS, 1L);
   }
 
   @Test
@@ -620,7 +587,7 @@ public void testSync_removesPendingSegment_ifNotPresentInMetadataStore()
 
     // Verify that sync removes the pending segment from the cache
     syncCache();
-    serviceEmitter.verifyValue(Metric.PERSISTED_PENDING_SEGMENTS, 0L);
+    serviceEmitter.verifyNotEmitted(Metric.PERSISTED_PENDING_SEGMENTS);
     serviceEmitter.verifyValue(Metric.DELETED_PENDING_SEGMENTS, 1L);
 
     Assert.assertTrue(
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/simulate/TestSegmentsMetadataManager.java b/server/src/test/java/org/apache/druid/server/coordinator/simulate/TestSegmentsMetadataManager.java
index 7b32560f9338..3cd7f8c0e2b8 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/simulate/TestSegmentsMetadataManager.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/simulate/TestSegmentsMetadataManager.java
@@ -21,6 +21,7 @@
 
 import com.google.common.base.Optional;
 import com.google.common.base.Predicates;
+import com.google.common.collect.Maps;
 import org.apache.druid.client.DataSourcesSnapshot;
 import org.apache.druid.client.ImmutableDruidDataSource;
 import org.apache.druid.metadata.SegmentsMetadataManager;
@@ -54,11 +55,14 @@ public class TestSegmentsMetadataManager implements SegmentsMetadataManager
   private volatile DataSourcesSnapshot snapshot;
   private volatile boolean pollingStarted;
 
-  public void addSegment(DataSegment segment)
+  public boolean addSegment(DataSegment segment)
   {
     allSegments.put(segment.getId().toString(), segment);
-    usedSegments.put(segment.getId().toString(), segment);
+    boolean added = usedSegments.put(segment.getId().toString(), segment) != null;
+
     invalidateDatasourcesSnapshot();
+
+    return added;
   }
 
   public void removeSegment(DataSegment segment)
@@ -68,6 +72,16 @@ public void removeSegment(DataSegment segment)
     invalidateDatasourcesSnapshot();
   }
 
+  public Set<DataSegment> getAllUnusedSegments()
+  {
+    return Set.copyOf(Maps.difference(allSegments, usedSegments).entriesOnlyOnLeft().values());
+  }
+
+  public Set<DataSegment> getAllSegments()
+  {
+    return Set.copyOf(allSegments.values());
+  }
+
   @Override
   public void startPollingDatabasePeriodically()
   {
@@ -104,9 +118,9 @@ public int markAsUsedNonOvershadowedSegmentsInInterval(String dataSource, Interv
   }
 
   @Override
-  public int markAsUsedNonOvershadowedSegments(String dataSource, Set<String> segmentIds)
+  public int markAsUsedNonOvershadowedSegments(String dataSource, Set<SegmentId> segmentIds)
   {
-    return markNonOvershadowedSegmentsAsUsed(dataSource, segment -> segmentIds.contains(segment.getId().toString()));
+    return markNonOvershadowedSegmentsAsUsed(dataSource, segment -> segmentIds.contains(segment.getId()));
   }
 
   @Override

From c17306f141e4cab31a4187287240c41949337896 Mon Sep 17 00:00:00 2001
From: Gian Merlino <gianmerlino@gmail.com>
Date: Wed, 26 Mar 2025 21:22:34 -0700
Subject: [PATCH 59/99] GroupBy: Fix offsets on outer queries. (#17837)

Prior to this patch, an offset specified on a groupBy that itself has an
inner groupBy would lead to an error like "Cannot push down offsets". This
happened because of a violated assumption: the processing logic assumes that
offsets have been pushed into limits (so limit pushdown optimizations can
safely be used).

This patch adjusts processing to incorporate offsets into limits during
processing of subqueries. Later on, in post-processing, offsets are applied
as written.
---
 .../druid/query/groupby/GroupingEngine.java   |  9 ++++-
 .../query/groupby/GroupByQueryRunnerTest.java | 33 +++++++++++++++++++
 2 files changed, 41 insertions(+), 1 deletion(-)

diff --git a/processing/src/main/java/org/apache/druid/query/groupby/GroupingEngine.java b/processing/src/main/java/org/apache/druid/query/groupby/GroupingEngine.java
index 91629706788b..3f85bbf63e1f 100644
--- a/processing/src/main/java/org/apache/druid/query/groupby/GroupingEngine.java
+++ b/processing/src/main/java/org/apache/druid/query/groupby/GroupingEngine.java
@@ -597,7 +597,7 @@ public Sequence<ResultRow> processSubqueryResult(
     GroupByRowProcessor.ResultSupplier resultSupplier = null;
 
     try {
-      final GroupByQuery queryToRun;
+      GroupByQuery queryToRun;
 
       if (wasQueryPushedDown) {
         // If the query was pushed down, filters would have been applied downstream, so skip it here.
@@ -607,6 +607,13 @@ public Sequence<ResultRow> processSubqueryResult(
         queryToRun = query;
       }
 
+      if (queryToRun.getLimitSpec() instanceof DefaultLimitSpec) {
+        // If the query has an offset, incorporate it into the limit before processing subquery results.
+        // This allows limit pushdown to work properly during processing. Later on, we'll use the GroupByQuery's
+        // postProcessingFn to apply the offset.
+        queryToRun = queryToRun.withLimitSpec(((DefaultLimitSpec) queryToRun.getLimitSpec()).withOffsetToLimit());
+      }
+
       resultSupplier = GroupByRowProcessor.process(
           queryToRun,
           wasQueryPushedDown ? queryToRun : subquery,
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java
index 300a74c8d2d3..67e4c5b1abe0 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java
@@ -6569,6 +6569,39 @@ public void testSubqueryWithPostAggregators()
     TestHelper.assertExpectedObjects(expectedResults, results, "subquery-postaggs");
   }
 
+  @Test
+  public void testSubqueryWithOuterOffsetAndLimit()
+  {
+    // Granularity != ALL requires time-ordering.
+    assumeTimeOrdered();
+
+    final GroupByQuery subquery = makeQueryBuilder()
+        .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
+        .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
+        .setDimensions(new DefaultDimensionSpec("quality", "alias"))
+        .setAggregatorSpecs(QueryRunnerTestHelper.ROWS_COUNT)
+        .setGranularity(QueryRunnerTestHelper.DAY_GRAN)
+        .build();
+
+    final GroupByQuery query = makeQueryBuilder()
+        .setDataSource(subquery)
+        .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
+        .setDimensions(new DefaultDimensionSpec("alias", "alias"))
+        .setAggregatorSpecs(new LongSumAggregatorFactory("rows", "rows"))
+        .setGranularity(QueryRunnerTestHelper.DAY_GRAN)
+        .setLimitSpec(new DefaultLimitSpec(null, 1, 2))
+        .build();
+
+    List<ResultRow> expectedResults = Arrays.asList(
+        makeRow(query, "2011-04-01", "alias", "business", "rows", 1L),
+        makeRow(query, "2011-04-01", "alias", "entertainment", "rows", 1L)
+    );
+
+    // Subqueries are handled by the ToolChest
+    Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
+    TestHelper.assertExpectedObjects(expectedResults, results, "subquery-postaggs");
+  }
+
   @Test
   public void testSubqueryWithPostAggregatorsAndHaving()
   {

From 3e947074aee0d138b0dd24dfd84058845396dafb Mon Sep 17 00:00:00 2001
From: Zoltan Haindrich <kirk@rxd.hu>
Date: Thu, 27 Mar 2025 09:21:39 +0100
Subject: [PATCH 60/99] Enable build cache for web-console (#17831)

---
 web-console/pom.xml | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/web-console/pom.xml b/web-console/pom.xml
index ab01d0f94ab9..80974b31b00f 100644
--- a/web-console/pom.xml
+++ b/web-console/pom.xml
@@ -32,6 +32,12 @@
   </parent>
 
   <properties>
+    <maven.build.cache.input.1>src</maven.build.cache.input.1>
+    <maven.build.cache.input.2>script</maven.build.cache.input.2>
+    <maven.build.cache.input.3>lib</maven.build.cache.input.3>
+    <maven.build.cache.input.4>assets</maven.build.cache.input.4>
+    <maven.build.cache.input.5>e2e-tests</maven.build.cache.input.5>
+    <maven.build.cache.input.6>typings</maven.build.cache.input.6>
     <resources.directory>${project.build.directory}/resources</resources.directory>
     <web.console.skip>false</web.console.skip>  <!-- this property is overidden in Travis CI to skip the javascript-related work -->
     <node.version>v20.9.0</node.version>
@@ -39,6 +45,13 @@
   </properties>
 
   <build>
+    <extensions>
+      <extension>
+        <groupId>org.apache.maven.extensions</groupId>
+        <artifactId>maven-build-cache-extension</artifactId>
+        <version>1.2.0</version>
+      </extension>
+    </extensions>
     <plugins>
       <plugin>
         <groupId>com.github.eirslett</groupId>

From 92d751d566dfbbf423d1551c491cd0a4a8055aa2 Mon Sep 17 00:00:00 2001
From: Vadim Ogievetsky <vadim@ogievetsky.com>
Date: Thu, 27 Mar 2025 01:46:45 -0700
Subject: [PATCH 61/99] run audit fix (#17836)

---
 licenses.yaml                 | 102 ++---------
 web-console/package-lock.json | 327 ++++++++++++++--------------------
 2 files changed, 145 insertions(+), 284 deletions(-)

diff --git a/licenses.yaml b/licenses.yaml
index 8f46132a18fe..8253cdd34881 100644
--- a/licenses.yaml
+++ b/licenses.yaml
@@ -5055,7 +5055,7 @@ license_category: binary
 module: web-console
 license_name: MIT License
 copyright: The Babel Team
-version: 7.23.5
+version: 7.26.2
 license_file_path: licenses/bin/@babel-code-frame.MIT
 
 ---
@@ -5075,7 +5075,7 @@ license_category: binary
 module: web-console
 license_name: MIT License
 copyright: The Babel Team
-version: 7.23.4
+version: 7.25.9
 license_file_path: licenses/bin/@babel-helper-string-parser.MIT
 
 ---
@@ -5085,27 +5085,17 @@ license_category: binary
 module: web-console
 license_name: MIT License
 copyright: The Babel Team
-version: 7.22.20
+version: 7.25.9
 license_file_path: licenses/bin/@babel-helper-validator-identifier.MIT
 
 ---
 
-name: "@babel/highlight"
-license_category: binary
-module: web-console
-license_name: MIT License
-copyright: The Babel Team
-version: 7.23.4
-license_file_path: licenses/bin/@babel-highlight.MIT
-
----
-
 name: "@babel/runtime"
 license_category: binary
 module: web-console
 license_name: MIT License
 copyright: The Babel Team
-version: 7.21.0
+version: 7.27.0
 license_file_path: licenses/bin/@babel-runtime.MIT
 
 ---
@@ -5115,7 +5105,7 @@ license_category: binary
 module: web-console
 license_name: MIT License
 copyright: The Babel Team
-version: 7.24.0
+version: 7.27.0
 license_file_path: licenses/bin/@babel-types.MIT
 
 ---
@@ -5362,16 +5352,6 @@ license_file_path: licenses/bin/ace-builds.BSD3
 
 ---
 
-name: "ansi-styles"
-license_category: binary
-module: web-console
-license_name: MIT License
-copyright: Sindre Sorhus
-version: 3.2.1
-license_file_path: licenses/bin/ansi-styles.MIT
-
----
-
 name: "asynckit"
 license_category: binary
 module: web-console
@@ -5387,7 +5367,7 @@ license_category: binary
 module: web-console
 license_name: MIT License
 copyright: Matt Zabriskie
-version: 1.7.7
+version: 1.8.4
 license_file_path: licenses/bin/axios.MIT
 
 ---
@@ -5452,16 +5432,6 @@ license_file_path: licenses/bin/capital-case.MIT
 
 ---
 
-name: "chalk"
-license_category: binary
-module: web-console
-license_name: MIT License
-copyright: Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
-version: 2.4.2
-license_file_path: licenses/bin/chalk.MIT
-
----
-
 name: "change-case"
 license_category: binary
 module: web-console
@@ -5491,26 +5461,6 @@ license_file_path: licenses/bin/classnames.MIT
 
 ---
 
-name: "color-convert"
-license_category: binary
-module: web-console
-license_name: MIT License
-copyright: Heather Arthur
-version: 1.9.3
-license_file_path: licenses/bin/color-convert.MIT
-
----
-
-name: "color-name"
-license_category: binary
-module: web-console
-license_name: MIT License
-copyright: DY
-version: 1.1.3
-license_file_path: licenses/bin/color-name.MIT
-
----
-
 name: "combined-stream"
 license_category: binary
 module: web-console
@@ -5878,16 +5828,6 @@ license_file_path: licenses/bin/function-bind.MIT
 
 ---
 
-name: "has-flag"
-license_category: binary
-module: web-console
-license_name: MIT License
-copyright: Sindre Sorhus
-version: 3.0.0
-license_file_path: licenses/bin/has-flag.MIT
-
----
-
 name: "hasown"
 license_category: binary
 module: web-console
@@ -6257,6 +6197,16 @@ license_file_path: licenses/bin/path-type.MIT
 
 ---
 
+name: "picocolors"
+license_category: binary
+module: web-console
+license_name: ISC License
+copyright: Alexey Raspopov
+version: 1.1.1
+license_file_path: licenses/bin/picocolors.ISC
+
+---
+
 name: "prop-types"
 license_category: binary
 module: web-console
@@ -6527,16 +6477,6 @@ license_file_path: licenses/bin/source-map.BSD3
 
 ---
 
-name: "supports-color"
-license_category: binary
-module: web-console
-license_name: MIT License
-copyright: Sindre Sorhus
-version: 5.5.0
-license_file_path: licenses/bin/supports-color.MIT
-
----
-
 name: "supports-preserve-symlinks-flag"
 license_category: binary
 module: web-console
@@ -6567,16 +6507,6 @@ license_file_path: licenses/bin/tiny-warning.MIT
 
 ---
 
-name: "to-fast-properties"
-license_category: binary
-module: web-console
-license_name: MIT License
-copyright: Sindre Sorhus
-version: 2.0.0
-license_file_path: licenses/bin/to-fast-properties.MIT
-
----
-
 name: "toggle-selection"
 license_category: binary
 module: web-console
diff --git a/web-console/package-lock.json b/web-console/package-lock.json
index e1f48743d00c..97a1d3e0538e 100644
--- a/web-console/package-lock.json
+++ b/web-console/package-lock.json
@@ -186,12 +186,14 @@
       }
     },
     "node_modules/@babel/code-frame": {
-      "version": "7.23.5",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.23.5.tgz",
-      "integrity": "sha512-CgH3s1a96LipHCmSUmYFPwY7MNx8C3avkq7i4Wl3cfa662ldtUe4VM1TPXX70pfmrlWTb6jLqTYrZyT2ZTJBgA==",
+      "version": "7.26.2",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.26.2.tgz",
+      "integrity": "sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ==",
+      "license": "MIT",
       "dependencies": {
-        "@babel/highlight": "^7.23.4",
-        "chalk": "^2.4.2"
+        "@babel/helper-validator-identifier": "^7.25.9",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.0.0"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -449,17 +451,19 @@
       }
     },
     "node_modules/@babel/helper-string-parser": {
-      "version": "7.23.4",
-      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.23.4.tgz",
-      "integrity": "sha512-803gmbQdqwdf4olxrX4AJyFBV/RTr3rSmOj0rKwesmzlfhYNDEs+/iOcznzpNWlJlIlTJC2QfPFcHB6DlzdVLQ==",
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.25.9.tgz",
+      "integrity": "sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA==",
+      "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-validator-identifier": {
-      "version": "7.22.20",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.20.tgz",
-      "integrity": "sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A==",
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.25.9.tgz",
+      "integrity": "sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==",
+      "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
@@ -474,37 +478,28 @@
       }
     },
     "node_modules/@babel/helpers": {
-      "version": "7.24.0",
-      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.24.0.tgz",
-      "integrity": "sha512-ulDZdc0Aj5uLc5nETsa7EPx2L7rM0YJM8r7ck7U73AXi7qOV44IHHRAYZHY6iU1rr3C5N4NtTmMRUJP6kwCWeA==",
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.27.0.tgz",
+      "integrity": "sha512-U5eyP/CTFPuNE3qk+WZMxFkp/4zUzdceQlfzf7DdGdhp+Fezd7HD+i8Y24ZuTMKX3wQBld449jijbGq6OdGNQg==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "@babel/template": "^7.24.0",
-        "@babel/traverse": "^7.24.0",
-        "@babel/types": "^7.24.0"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/highlight": {
-      "version": "7.23.4",
-      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.23.4.tgz",
-      "integrity": "sha512-acGdbYSfp2WheJoJm/EBBBLh/ID8KDc64ISZ9DYtBmC8/Q204PZJLHyzeB5qMzJ5trcOkybd78M4x2KWsUq++A==",
-      "dependencies": {
-        "@babel/helper-validator-identifier": "^7.22.20",
-        "chalk": "^2.4.2",
-        "js-tokens": "^4.0.0"
+        "@babel/template": "^7.27.0",
+        "@babel/types": "^7.27.0"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/parser": {
-      "version": "7.24.0",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.24.0.tgz",
-      "integrity": "sha512-QuP/FxEAzMSjXygs8v4N9dvdXzEHN4W1oF3PxuWAtPo08UdM17u89RDMgjLn/mlc56iM0HlLmVkO/wgR+rDgHg==",
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.27.0.tgz",
+      "integrity": "sha512-iaepho73/2Pz7w2eMS0Q5f83+0RKI7i4xmiYeBmDzfRVbQtTOG7Ts0S4HzJVsTMGI9keU8rNfuZr8DKfSt7Yyg==",
       "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.27.0"
+      },
       "bin": {
         "parser": "bin/babel-parser.js"
       },
@@ -690,25 +685,33 @@
       }
     },
     "node_modules/@babel/runtime": {
-      "version": "7.21.0",
-      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.21.0.tgz",
-      "integrity": "sha512-xwII0//EObnq89Ji5AKYQaRYiW/nZ3llSv29d49IuxPhKbtJoLP+9QUUZ4nVragQVtaVGeZrpB+ZtG/Pdy/POw==",
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.27.0.tgz",
+      "integrity": "sha512-VtPOkrdPHZsKc/clNqyi9WUA8TINkZ4cGk63UUE3u4pmB2k+ZMQRDuIOagv8UVd6j7k0T3+RRIb7beKTebNbcw==",
+      "license": "MIT",
       "dependencies": {
-        "regenerator-runtime": "^0.13.11"
+        "regenerator-runtime": "^0.14.0"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@babel/runtime/node_modules/regenerator-runtime": {
+      "version": "0.14.1",
+      "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz",
+      "integrity": "sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==",
+      "license": "MIT"
+    },
     "node_modules/@babel/template": {
-      "version": "7.24.0",
-      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.24.0.tgz",
-      "integrity": "sha512-Bkf2q8lMB0AFpX0NFEqSbx1OkTHf0f+0j82mkw+ZpzBnkk7e9Ql0891vlfgi+kHwOk8tQjiQHpqh4LaSa0fKEA==",
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.0.tgz",
+      "integrity": "sha512-2ncevenBqXI6qRMukPlXwHKHchC7RyMuu4xv5JBXRfOGVcTy1mXCD12qrp7Jsoxll1EV3+9sE4GugBVRjT2jFA==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^7.23.5",
-        "@babel/parser": "^7.24.0",
-        "@babel/types": "^7.24.0"
+        "@babel/code-frame": "^7.26.2",
+        "@babel/parser": "^7.27.0",
+        "@babel/types": "^7.27.0"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -769,13 +772,13 @@
       "dev": true
     },
     "node_modules/@babel/types": {
-      "version": "7.24.0",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.24.0.tgz",
-      "integrity": "sha512-+j7a5c253RfKh8iABBhywc8NSfP5LURe7Uh4qpsh6jc+aLJguvmIUBdjSdEMQv2bENrCR5MfRdjGo7vzS/ob7w==",
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.27.0.tgz",
+      "integrity": "sha512-H45s8fVLYjbhFH62dIJ3WtmJ6RSPt/3DRO0ZcT2SUiYiQyz3BLVb9ADEnLl91m74aQPS3AzzeajZHYOalWe3bg==",
+      "license": "MIT",
       "dependencies": {
-        "@babel/helper-string-parser": "^7.23.4",
-        "@babel/helper-validator-identifier": "^7.22.20",
-        "to-fast-properties": "^2.0.0"
+        "@babel/helper-string-parser": "^7.25.9",
+        "@babel/helper-validator-identifier": "^7.25.9"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -4933,6 +4936,7 @@
       "version": "3.2.1",
       "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
       "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+      "dev": true,
       "dependencies": {
         "color-convert": "^1.9.0"
       },
@@ -5235,12 +5239,6 @@
         "postcss": "^8.1.0"
       }
     },
-    "node_modules/autoprefixer/node_modules/picocolors": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.0.tgz",
-      "integrity": "sha512-TQ92mBOW0l3LeMeyLV6mzy/kWr8lkd/hp3mTg7wYK7zJhuBStmGMBG0BdeDZS/dZx1IukaX6Bk11zcln25o1Aw==",
-      "dev": true
-    },
     "node_modules/available-typed-arrays": {
       "version": "1.0.7",
       "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz",
@@ -5258,9 +5256,9 @@
       }
     },
     "node_modules/axios": {
-      "version": "1.7.7",
-      "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.7.tgz",
-      "integrity": "sha512-S4kL7XrjgBmvdGut0sN3yJxqYzrDOnivkBiN0OFs6hLiUam3UPvswUo0kqGyhqUZGEOytHyumEdXsAkgCOUf3Q==",
+      "version": "1.8.4",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.8.4.tgz",
+      "integrity": "sha512-eBSYY4Y68NNlHbHBMdeDmKNtDgXWhQsJcGqzO3iLUM0GraQFSS9cVgPX5I9b3lbdFKyYoAEGAZF1DwhTaljNAw==",
       "license": "MIT",
       "dependencies": {
         "follow-redirects": "^1.15.6",
@@ -5765,6 +5763,7 @@
       "version": "2.4.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
       "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
+      "dev": true,
       "dependencies": {
         "ansi-styles": "^3.2.1",
         "escape-string-regexp": "^1.0.5",
@@ -5933,6 +5932,7 @@
       "version": "1.9.3",
       "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
       "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+      "dev": true,
       "dependencies": {
         "color-name": "1.1.3"
       }
@@ -5940,7 +5940,8 @@
     "node_modules/color-name": {
       "version": "1.1.3",
       "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
-      "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU="
+      "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=",
+      "dev": true
     },
     "node_modules/colord": {
       "version": "2.9.3",
@@ -8970,6 +8971,7 @@
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
       "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
+      "dev": true,
       "engines": {
         "node": ">=4"
       }
@@ -12573,12 +12575,6 @@
         "shell-quote": "^1.8.1"
       }
     },
-    "node_modules/launch-editor/node_modules/picocolors": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz",
-      "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==",
-      "dev": true
-    },
     "node_modules/leven": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz",
@@ -13595,6 +13591,12 @@
         "node": ">=8"
       }
     },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "license": "ISC"
+    },
     "node_modules/picomatch": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
@@ -14598,12 +14600,6 @@
       "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==",
       "dev": true
     },
-    "node_modules/postcss/node_modules/picocolors": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.0.tgz",
-      "integrity": "sha512-TQ92mBOW0l3LeMeyLV6mzy/kWr8lkd/hp3mTg7wYK7zJhuBStmGMBG0BdeDZS/dZx1IukaX6Bk11zcln25o1Aw==",
-      "dev": true
-    },
     "node_modules/prelude-ls": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
@@ -16689,13 +16685,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/stylelint/node_modules/picocolors": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
-      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
-      "dev": true,
-      "license": "ISC"
-    },
     "node_modules/stylelint/node_modules/resolve-from": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz",
@@ -16709,6 +16698,7 @@
       "version": "5.5.0",
       "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
       "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+      "dev": true,
       "dependencies": {
         "has-flag": "^3.0.0"
       },
@@ -16958,14 +16948,6 @@
       "integrity": "sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==",
       "dev": true
     },
-    "node_modules/to-fast-properties": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz",
-      "integrity": "sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4=",
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/to-regex-range": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
@@ -17533,12 +17515,6 @@
         "browserslist": ">= 4.21.0"
       }
     },
-    "node_modules/update-browserslist-db/node_modules/picocolors": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.0.tgz",
-      "integrity": "sha512-TQ92mBOW0l3LeMeyLV6mzy/kWr8lkd/hp3mTg7wYK7zJhuBStmGMBG0BdeDZS/dZx1IukaX6Bk11zcln25o1Aw==",
-      "dev": true
-    },
     "node_modules/upper-case": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/upper-case/-/upper-case-2.0.2.tgz",
@@ -17844,12 +17820,6 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/webpack-bundle-analyzer/node_modules/picocolors": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz",
-      "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==",
-      "dev": true
-    },
     "node_modules/webpack-cli": {
       "version": "5.1.4",
       "resolved": "https://registry.npmjs.org/webpack-cli/-/webpack-cli-5.1.4.tgz",
@@ -18620,12 +18590,13 @@
       }
     },
     "@babel/code-frame": {
-      "version": "7.23.5",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.23.5.tgz",
-      "integrity": "sha512-CgH3s1a96LipHCmSUmYFPwY7MNx8C3avkq7i4Wl3cfa662ldtUe4VM1TPXX70pfmrlWTb6jLqTYrZyT2ZTJBgA==",
+      "version": "7.26.2",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.26.2.tgz",
+      "integrity": "sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ==",
       "requires": {
-        "@babel/highlight": "^7.23.4",
-        "chalk": "^2.4.2"
+        "@babel/helper-validator-identifier": "^7.25.9",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.0.0"
       }
     },
     "@babel/compat-data": {
@@ -18823,14 +18794,14 @@
       }
     },
     "@babel/helper-string-parser": {
-      "version": "7.23.4",
-      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.23.4.tgz",
-      "integrity": "sha512-803gmbQdqwdf4olxrX4AJyFBV/RTr3rSmOj0rKwesmzlfhYNDEs+/iOcznzpNWlJlIlTJC2QfPFcHB6DlzdVLQ=="
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.25.9.tgz",
+      "integrity": "sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA=="
     },
     "@babel/helper-validator-identifier": {
-      "version": "7.22.20",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.20.tgz",
-      "integrity": "sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A=="
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.25.9.tgz",
+      "integrity": "sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ=="
     },
     "@babel/helper-validator-option": {
       "version": "7.23.5",
@@ -18839,32 +18810,24 @@
       "dev": true
     },
     "@babel/helpers": {
-      "version": "7.24.0",
-      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.24.0.tgz",
-      "integrity": "sha512-ulDZdc0Aj5uLc5nETsa7EPx2L7rM0YJM8r7ck7U73AXi7qOV44IHHRAYZHY6iU1rr3C5N4NtTmMRUJP6kwCWeA==",
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.27.0.tgz",
+      "integrity": "sha512-U5eyP/CTFPuNE3qk+WZMxFkp/4zUzdceQlfzf7DdGdhp+Fezd7HD+i8Y24ZuTMKX3wQBld449jijbGq6OdGNQg==",
       "dev": true,
       "requires": {
-        "@babel/template": "^7.24.0",
-        "@babel/traverse": "^7.24.0",
-        "@babel/types": "^7.24.0"
+        "@babel/template": "^7.27.0",
+        "@babel/types": "^7.27.0"
       }
     },
-    "@babel/highlight": {
-      "version": "7.23.4",
-      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.23.4.tgz",
-      "integrity": "sha512-acGdbYSfp2WheJoJm/EBBBLh/ID8KDc64ISZ9DYtBmC8/Q204PZJLHyzeB5qMzJ5trcOkybd78M4x2KWsUq++A==",
+    "@babel/parser": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.27.0.tgz",
+      "integrity": "sha512-iaepho73/2Pz7w2eMS0Q5f83+0RKI7i4xmiYeBmDzfRVbQtTOG7Ts0S4HzJVsTMGI9keU8rNfuZr8DKfSt7Yyg==",
+      "dev": true,
       "requires": {
-        "@babel/helper-validator-identifier": "^7.22.20",
-        "chalk": "^2.4.2",
-        "js-tokens": "^4.0.0"
+        "@babel/types": "^7.27.0"
       }
     },
-    "@babel/parser": {
-      "version": "7.24.0",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.24.0.tgz",
-      "integrity": "sha512-QuP/FxEAzMSjXygs8v4N9dvdXzEHN4W1oF3PxuWAtPo08UdM17u89RDMgjLn/mlc56iM0HlLmVkO/wgR+rDgHg==",
-      "dev": true
-    },
     "@babel/plugin-syntax-async-generators": {
       "version": "7.8.4",
       "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz",
@@ -18992,22 +18955,29 @@
       }
     },
     "@babel/runtime": {
-      "version": "7.21.0",
-      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.21.0.tgz",
-      "integrity": "sha512-xwII0//EObnq89Ji5AKYQaRYiW/nZ3llSv29d49IuxPhKbtJoLP+9QUUZ4nVragQVtaVGeZrpB+ZtG/Pdy/POw==",
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.27.0.tgz",
+      "integrity": "sha512-VtPOkrdPHZsKc/clNqyi9WUA8TINkZ4cGk63UUE3u4pmB2k+ZMQRDuIOagv8UVd6j7k0T3+RRIb7beKTebNbcw==",
       "requires": {
-        "regenerator-runtime": "^0.13.11"
+        "regenerator-runtime": "^0.14.0"
+      },
+      "dependencies": {
+        "regenerator-runtime": {
+          "version": "0.14.1",
+          "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz",
+          "integrity": "sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw=="
+        }
       }
     },
     "@babel/template": {
-      "version": "7.24.0",
-      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.24.0.tgz",
-      "integrity": "sha512-Bkf2q8lMB0AFpX0NFEqSbx1OkTHf0f+0j82mkw+ZpzBnkk7e9Ql0891vlfgi+kHwOk8tQjiQHpqh4LaSa0fKEA==",
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.0.tgz",
+      "integrity": "sha512-2ncevenBqXI6qRMukPlXwHKHchC7RyMuu4xv5JBXRfOGVcTy1mXCD12qrp7Jsoxll1EV3+9sE4GugBVRjT2jFA==",
       "dev": true,
       "requires": {
-        "@babel/code-frame": "^7.23.5",
-        "@babel/parser": "^7.24.0",
-        "@babel/types": "^7.24.0"
+        "@babel/code-frame": "^7.26.2",
+        "@babel/parser": "^7.27.0",
+        "@babel/types": "^7.27.0"
       }
     },
     "@babel/traverse": {
@@ -19052,13 +19022,12 @@
       }
     },
     "@babel/types": {
-      "version": "7.24.0",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.24.0.tgz",
-      "integrity": "sha512-+j7a5c253RfKh8iABBhywc8NSfP5LURe7Uh4qpsh6jc+aLJguvmIUBdjSdEMQv2bENrCR5MfRdjGo7vzS/ob7w==",
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.27.0.tgz",
+      "integrity": "sha512-H45s8fVLYjbhFH62dIJ3WtmJ6RSPt/3DRO0ZcT2SUiYiQyz3BLVb9ADEnLl91m74aQPS3AzzeajZHYOalWe3bg==",
       "requires": {
-        "@babel/helper-string-parser": "^7.23.4",
-        "@babel/helper-validator-identifier": "^7.22.20",
-        "to-fast-properties": "^2.0.0"
+        "@babel/helper-string-parser": "^7.25.9",
+        "@babel/helper-validator-identifier": "^7.25.9"
       }
     },
     "@bcoe/v8-coverage": {
@@ -21805,6 +21774,7 @@
       "version": "3.2.1",
       "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
       "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+      "dev": true,
       "requires": {
         "color-convert": "^1.9.0"
       }
@@ -22007,14 +21977,6 @@
         "normalize-range": "^0.1.2",
         "picocolors": "^1.0.1",
         "postcss-value-parser": "^4.2.0"
-      },
-      "dependencies": {
-        "picocolors": {
-          "version": "1.1.0",
-          "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.0.tgz",
-          "integrity": "sha512-TQ92mBOW0l3LeMeyLV6mzy/kWr8lkd/hp3mTg7wYK7zJhuBStmGMBG0BdeDZS/dZx1IukaX6Bk11zcln25o1Aw==",
-          "dev": true
-        }
       }
     },
     "available-typed-arrays": {
@@ -22027,9 +21989,9 @@
       }
     },
     "axios": {
-      "version": "1.7.7",
-      "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.7.tgz",
-      "integrity": "sha512-S4kL7XrjgBmvdGut0sN3yJxqYzrDOnivkBiN0OFs6hLiUam3UPvswUo0kqGyhqUZGEOytHyumEdXsAkgCOUf3Q==",
+      "version": "1.8.4",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.8.4.tgz",
+      "integrity": "sha512-eBSYY4Y68NNlHbHBMdeDmKNtDgXWhQsJcGqzO3iLUM0GraQFSS9cVgPX5I9b3lbdFKyYoAEGAZF1DwhTaljNAw==",
       "requires": {
         "follow-redirects": "^1.15.6",
         "form-data": "^4.0.0",
@@ -22417,6 +22379,7 @@
       "version": "2.4.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
       "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
+      "dev": true,
       "requires": {
         "ansi-styles": "^3.2.1",
         "escape-string-regexp": "^1.0.5",
@@ -22547,6 +22510,7 @@
       "version": "1.9.3",
       "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
       "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+      "dev": true,
       "requires": {
         "color-name": "1.1.3"
       }
@@ -22554,7 +22518,8 @@
     "color-name": {
       "version": "1.1.3",
       "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
-      "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU="
+      "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=",
+      "dev": true
     },
     "colord": {
       "version": "2.9.3",
@@ -24718,7 +24683,8 @@
     "has-flag": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-      "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0="
+      "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
+      "dev": true
     },
     "has-property-descriptors": {
       "version": "1.0.2",
@@ -27326,14 +27292,6 @@
       "requires": {
         "picocolors": "^1.0.0",
         "shell-quote": "^1.8.1"
-      },
-      "dependencies": {
-        "picocolors": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz",
-          "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==",
-          "dev": true
-        }
       }
     },
     "leven": {
@@ -28094,6 +28052,11 @@
       "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz",
       "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw=="
     },
+    "picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="
+    },
     "picomatch": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
@@ -28147,14 +28110,6 @@
         "nanoid": "^3.3.7",
         "picocolors": "^1.1.0",
         "source-map-js": "^1.2.1"
-      },
-      "dependencies": {
-        "picocolors": {
-          "version": "1.1.0",
-          "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.0.tgz",
-          "integrity": "sha512-TQ92mBOW0l3LeMeyLV6mzy/kWr8lkd/hp3mTg7wYK7zJhuBStmGMBG0BdeDZS/dZx1IukaX6Bk11zcln25o1Aw==",
-          "dev": true
-        }
       }
     },
     "postcss-attribute-case-insensitive": {
@@ -30061,12 +30016,6 @@
           "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
           "dev": true
         },
-        "picocolors": {
-          "version": "1.1.1",
-          "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
-          "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
-          "dev": true
-        },
         "resolve-from": {
           "version": "5.0.0",
           "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz",
@@ -30120,6 +30069,7 @@
       "version": "5.5.0",
       "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
       "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+      "dev": true,
       "requires": {
         "has-flag": "^3.0.0"
       }
@@ -30304,11 +30254,6 @@
       "integrity": "sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==",
       "dev": true
     },
-    "to-fast-properties": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz",
-      "integrity": "sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4="
-    },
     "to-regex-range": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
@@ -30656,14 +30601,6 @@
       "requires": {
         "escalade": "^3.2.0",
         "picocolors": "^1.1.0"
-      },
-      "dependencies": {
-        "picocolors": {
-          "version": "1.1.0",
-          "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.0.tgz",
-          "integrity": "sha512-TQ92mBOW0l3LeMeyLV6mzy/kWr8lkd/hp3mTg7wYK7zJhuBStmGMBG0BdeDZS/dZx1IukaX6Bk11zcln25o1Aw==",
-          "dev": true
-        }
       }
     },
     "upper-case": {
@@ -30911,12 +30848,6 @@
           "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz",
           "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==",
           "dev": true
-        },
-        "picocolors": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz",
-          "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==",
-          "dev": true
         }
       }
     },

From 518345ddc412bfcff96f3e7243c801c9f37f6b0d Mon Sep 17 00:00:00 2001
From: Kashif Faraz <kashif.faraz@gmail.com>
Date: Fri, 28 Mar 2025 04:50:31 +0530
Subject: [PATCH 62/99] Do not block task actions on Overlord if segment
 metadata cache is syncing (#17824)

* Do not use segment metadata cache until leader has synced

* Read from cache only when synced, but write even if sync is pending

* Fix compilation

* Fix checkstyle, test

* Revert some extra changes

* Add 3 modes of cache usage

* Move enum to SegmentMetadataCache

* Run tests in all 3 cache modes

* Fix docs and IT configs

* Fix config binding

* Remove forbidden api

* Fix typos, docs and enum casing

* Fix doc
---
 docs/configuration/index.md                   |   4 +-
 .../MaterializedViewSupervisorTest.java       |   4 +-
 .../DatasourceOptimizerTest.java              |   3 +-
 .../actions/RetrieveSegmentsActionsTest.java  |   1 -
 .../common/actions/TaskActionTestKit.java     |  15 +-
 .../common/task/IngestionTestBase.java        |   9 +-
 .../overlord/TaskLockBoxConcurrencyTest.java  |   4 +-
 .../indexing/overlord/TaskLockboxTest.java    |   7 +-
 .../indexing/overlord/TaskQueueScaleTest.java |   3 +-
 .../SeekableStreamIndexTaskTestBase.java      |   4 +-
 .../Common/environment-configs/overlord.env   |   4 +-
 .../docker/environment-configs/overlord       |   4 +-
 .../IndexerSQLMetadataStorageCoordinator.java |   9 +-
 .../SegmentsMetadataManagerConfig.java        |   9 +-
 .../CachedSegmentMetadataTransaction.java     |  82 +++++++---
 .../SqlSegmentMetadataTransactionFactory.java |  47 +++++-
 .../cache/HeapMemorySegmentMetadataCache.java |  76 +++++++---
 .../druid/metadata/segment/cache/Metric.java  |  14 +-
 .../cache/NoopSegmentMetadataCache.java       |  13 ++
 .../segment/cache/SegmentMetadataCache.java   |  60 ++++++++
 ...exerSQLMetadataStorageCoordinatorTest.java | 141 +++++++++++++++---
 ...orageCoordinatorSchemaPersistenceTest.java |   4 +-
 ...SegmentsMetadataManagerSchemaPollTest.java |   6 +-
 .../SqlSegmentsMetadataManagerTest.java       |   4 +-
 .../HeapMemorySegmentMetadataCacheTest.java   |  44 ++----
 .../duty/KillUnusedSegmentsTest.java          |   2 +-
 26 files changed, 439 insertions(+), 134 deletions(-)

diff --git a/docs/configuration/index.md b/docs/configuration/index.md
index 687e1d688a67..b3f4f38d5ca4 100644
--- a/docs/configuration/index.md
+++ b/docs/configuration/index.md
@@ -1175,8 +1175,8 @@ The following properties pertain to segment metadata caching on the Overlord tha
 
 |Property|Description|Default|
 |--------|-----------|-------|
-|`druid.manager.segments.useCache`|If `true`, segment metadata is cached on the Overlord to speed up metadata operations.|false|
-|`druid.manager.segments.pollDuration`|Duration (in ISO 8601 format) between successive syncs of the cache with the metadata store. This property is used only when `druid.manager.segments.useCache` is `true`.|`PT1M` (1 minute)|
+|`druid.manager.segments.useCache`|Denotes the usage mode of the segment metadata cache. Possible modes are: (a) `never`: Cache is disabled. (b) `always`: Reads are always done from the cache. Service start-up will be blocked until cache has synced with the metadata store at least once. Transactions will block until cache has synced with the metadata store at least once after becoming leader. (c) `ifSynced`: Reads are done from the cache only if it has already synced with the metadata store. This mode does not block service start-up or transactions.|`never`|
+|`druid.manager.segments.pollDuration`|Duration (in ISO 8601 format) between successive syncs of the cache with the metadata store. This property is used only when `druid.manager.segments.useCache` is set to `always` or `ifSynced`.|`PT1M` (1 minute)|
 
 #### Overlord dynamic configuration
 
diff --git a/extensions-contrib/materialized-view-maintenance/src/test/java/org/apache/druid/indexing/materializedview/MaterializedViewSupervisorTest.java b/extensions-contrib/materialized-view-maintenance/src/test/java/org/apache/druid/indexing/materializedview/MaterializedViewSupervisorTest.java
index 6c39d21c1f59..444eb7cb61b9 100644
--- a/extensions-contrib/materialized-view-maintenance/src/test/java/org/apache/druid/indexing/materializedview/MaterializedViewSupervisorTest.java
+++ b/extensions-contrib/materialized-view-maintenance/src/test/java/org/apache/druid/indexing/materializedview/MaterializedViewSupervisorTest.java
@@ -56,6 +56,7 @@
 import org.apache.druid.segment.metadata.SegmentSchemaManager;
 import org.apache.druid.segment.realtime.ChatHandlerProvider;
 import org.apache.druid.server.coordinator.simulate.TestDruidLeaderSelector;
+import org.apache.druid.server.metrics.NoopServiceEmitter;
 import org.apache.druid.server.security.AuthorizerMapper;
 import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.partition.HashBasedNumberedShardSpec;
@@ -113,7 +114,8 @@ public void setUp()
             derbyConnectorRule.metadataTablesConfigSupplier().get(),
             derbyConnector,
             new TestDruidLeaderSelector(),
-            new NoopSegmentMetadataCache()
+            NoopSegmentMetadataCache.instance(),
+            NoopServiceEmitter.instance()
         ),
         objectMapper,
         derbyConnectorRule.metadataTablesConfigSupplier().get(),
diff --git a/extensions-contrib/materialized-view-selection/src/test/java/org/apache/druid/query/materializedview/DatasourceOptimizerTest.java b/extensions-contrib/materialized-view-selection/src/test/java/org/apache/druid/query/materializedview/DatasourceOptimizerTest.java
index 999a38ffd3a0..606c6a529587 100644
--- a/extensions-contrib/materialized-view-selection/src/test/java/org/apache/druid/query/materializedview/DatasourceOptimizerTest.java
+++ b/extensions-contrib/materialized-view-selection/src/test/java/org/apache/druid/query/materializedview/DatasourceOptimizerTest.java
@@ -120,7 +120,8 @@ public void setUp() throws Exception
             derbyConnectorRule.metadataTablesConfigSupplier().get(),
             derbyConnector,
             new TestDruidLeaderSelector(),
-            new NoopSegmentMetadataCache()
+            NoopSegmentMetadataCache.instance(),
+            NoopServiceEmitter.instance()
         ),
         jsonMapper,
         derbyConnectorRule.metadataTablesConfigSupplier().get(),
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/RetrieveSegmentsActionsTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/RetrieveSegmentsActionsTest.java
index 5800e3b1ec15..8ef97352921f 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/RetrieveSegmentsActionsTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/RetrieveSegmentsActionsTest.java
@@ -99,7 +99,6 @@ private static DataSegment createSegment(Interval interval, String version)
   @Test
   public void testRetrieveUsedSegmentsAction()
   {
-    actionTestKit.syncSegmentMetadataCache();
     final RetrieveUsedSegmentsAction action =
         new RetrieveUsedSegmentsAction(task.getDataSource(), ImmutableList.of(INTERVAL));
     final Set<DataSegment> observedUsedSegments = new HashSet<>(action.perform(task, actionTestKit.getTaskActionToolbox()));
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/TaskActionTestKit.java b/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/TaskActionTestKit.java
index 352b062fe947..ed30db142a95 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/TaskActionTestKit.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/TaskActionTestKit.java
@@ -66,7 +66,7 @@ public class TaskActionTestKit extends ExternalResource
   private SegmentMetadataCache segmentMetadataCache;
   private BlockingExecutorService metadataCachePollExec;
 
-  private boolean useSegmentMetadataCache = new SegmentsMetadataManagerConfig(null, null).isUseCache();
+  private boolean useSegmentMetadataCache = false;
   private boolean skipSegmentPayloadFetchForAllocation = new TaskLockConfig().isBatchAllocationReduceMetadataIO();
 
   public TaskLockbox getTaskLockbox()
@@ -182,13 +182,17 @@ public boolean isBatchAllocationReduceMetadataIO()
   private SqlSegmentMetadataTransactionFactory setupTransactionFactory(ObjectMapper objectMapper)
   {
     metadataCachePollExec = new BlockingExecutorService("test-cache-poll-exec");
+    SegmentMetadataCache.UsageMode cacheMode
+        = useSegmentMetadataCache
+          ? SegmentMetadataCache.UsageMode.ALWAYS
+          : SegmentMetadataCache.UsageMode.NEVER;
     segmentMetadataCache = new HeapMemorySegmentMetadataCache(
         objectMapper,
-        Suppliers.ofInstance(new SegmentsMetadataManagerConfig(Period.seconds(1), useSegmentMetadataCache)),
+        Suppliers.ofInstance(new SegmentsMetadataManagerConfig(Period.seconds(1), cacheMode)),
         Suppliers.ofInstance(metadataStorageTablesConfig),
         testDerbyConnector,
         (poolSize, name) -> new WrappingScheduledExecutorService(name, metadataCachePollExec, false),
-        new NoopServiceEmitter()
+        NoopServiceEmitter.instance()
     );
 
     final TestDruidLeaderSelector leaderSelector = new TestDruidLeaderSelector();
@@ -199,7 +203,8 @@ private SqlSegmentMetadataTransactionFactory setupTransactionFactory(ObjectMappe
         metadataStorageTablesConfig,
         testDerbyConnector,
         leaderSelector,
-        segmentMetadataCache
+        segmentMetadataCache,
+        NoopServiceEmitter.instance()
     )
     {
       @Override
@@ -222,6 +227,6 @@ public void after()
     taskActionToolbox = null;
     segmentMetadataCache.stopBeingLeader();
     segmentMetadataCache.stop();
-    useSegmentMetadataCache = new SegmentsMetadataManagerConfig(null, null).isUseCache();
+    useSegmentMetadataCache = false;
   }
 }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/common/task/IngestionTestBase.java b/indexing-service/src/test/java/org/apache/druid/indexing/common/task/IngestionTestBase.java
index 57a918cd9e50..6e7b30b4be27 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/common/task/IngestionTestBase.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/common/task/IngestionTestBase.java
@@ -315,9 +315,13 @@ public TaskToolbox createTaskToolbox(TaskConfig config, Task task, SupervisorMan
 
   private SqlSegmentMetadataTransactionFactory createTransactionFactory()
   {
+    final SegmentMetadataCache.UsageMode cacheMode
+        = useSegmentMetadataCache
+          ? SegmentMetadataCache.UsageMode.ALWAYS
+          : SegmentMetadataCache.UsageMode.NEVER;
     segmentMetadataCache = new HeapMemorySegmentMetadataCache(
         objectMapper,
-        Suppliers.ofInstance(new SegmentsMetadataManagerConfig(Period.millis(10), useSegmentMetadataCache)),
+        Suppliers.ofInstance(new SegmentsMetadataManagerConfig(Period.millis(10), cacheMode)),
         derbyConnectorRule.metadataTablesConfigSupplier(),
         derbyConnectorRule.getConnector(),
         ScheduledExecutors::fixed,
@@ -332,7 +336,8 @@ private SqlSegmentMetadataTransactionFactory createTransactionFactory()
         derbyConnectorRule.metadataTablesConfigSupplier().get(),
         derbyConnectorRule.getConnector(),
         leaderSelector,
-        segmentMetadataCache
+        segmentMetadataCache,
+        NoopServiceEmitter.instance()
     );
   }
 
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLockBoxConcurrencyTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLockBoxConcurrencyTest.java
index 6436ad3d35ca..a55117aad12d 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLockBoxConcurrencyTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLockBoxConcurrencyTest.java
@@ -38,6 +38,7 @@
 import org.apache.druid.segment.metadata.CentralizedDatasourceSchemaConfig;
 import org.apache.druid.segment.metadata.SegmentSchemaManager;
 import org.apache.druid.server.coordinator.simulate.TestDruidLeaderSelector;
+import org.apache.druid.server.metrics.NoopServiceEmitter;
 import org.joda.time.Interval;
 import org.junit.After;
 import org.junit.Assert;
@@ -88,7 +89,8 @@ public void setup()
                 derby.metadataTablesConfigSupplier().get(),
                 derbyConnector,
                 new TestDruidLeaderSelector(),
-                new NoopSegmentMetadataCache()
+                NoopSegmentMetadataCache.instance(),
+                NoopServiceEmitter.instance()
             ),
             objectMapper,
             derby.metadataTablesConfigSupplier().get(),
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLockboxTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLockboxTest.java
index 8e72d21fda81..48c5b5c4e94a 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLockboxTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLockboxTest.java
@@ -63,6 +63,7 @@
 import org.apache.druid.segment.metadata.SegmentSchemaManager;
 import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
 import org.apache.druid.server.coordinator.simulate.TestDruidLeaderSelector;
+import org.apache.druid.server.metrics.NoopServiceEmitter;
 import org.apache.druid.timeline.partition.HashBasedNumberedPartialShardSpec;
 import org.apache.druid.timeline.partition.HashBasedNumberedShardSpec;
 import org.apache.druid.timeline.partition.NumberedOverwritePartialShardSpec;
@@ -136,7 +137,8 @@ public void setup()
             tablesConfig,
             derbyConnector,
             new TestDruidLeaderSelector(),
-            new NoopSegmentMetadataCache()
+            NoopSegmentMetadataCache.instance(),
+            NoopServiceEmitter.instance()
         ),
         objectMapper,
         tablesConfig,
@@ -477,7 +479,8 @@ public void testSyncWithUnknownTaskTypesFromModuleNotLoaded()
             derby.metadataTablesConfigSupplier().get(),
             derbyConnector,
             new TestDruidLeaderSelector(),
-            new NoopSegmentMetadataCache()
+            NoopSegmentMetadataCache.instance(),
+            NoopServiceEmitter.instance()
         ),
         loadedMapper,
         derby.metadataTablesConfigSupplier().get(),
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskQueueScaleTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskQueueScaleTest.java
index 80026f137269..f54ea7fe5860 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskQueueScaleTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskQueueScaleTest.java
@@ -111,7 +111,8 @@ public void setUp()
             derbyConnectorRule.metadataTablesConfigSupplier().get(),
             derbyConnectorRule.getConnector(),
             new TestDruidLeaderSelector(),
-            new NoopSegmentMetadataCache()
+            NoopSegmentMetadataCache.instance(),
+            NoopServiceEmitter.instance()
         ),
         jsonMapper,
         derbyConnectorRule.metadataTablesConfigSupplier().get(),
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTaskTestBase.java b/indexing-service/src/test/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTaskTestBase.java
index 214c024b4548..9e82196f8117 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTaskTestBase.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTaskTestBase.java
@@ -123,6 +123,7 @@
 import org.apache.druid.server.coordination.DataSegmentServerAnnouncer;
 import org.apache.druid.server.coordination.ServerType;
 import org.apache.druid.server.coordinator.simulate.TestDruidLeaderSelector;
+import org.apache.druid.server.metrics.NoopServiceEmitter;
 import org.apache.druid.server.security.AuthTestUtils;
 import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.utils.CompressionUtils;
@@ -595,7 +596,8 @@ protected void makeToolboxFactory(TestUtils testUtils, ServiceEmitter emitter, b
             derby.metadataTablesConfigSupplier().get(),
             derbyConnector,
             new TestDruidLeaderSelector(),
-            new NoopSegmentMetadataCache()
+            NoopSegmentMetadataCache.instance(),
+            NoopServiceEmitter.instance()
         ),
         objectMapper,
         derby.metadataTablesConfigSupplier().get(),
diff --git a/integration-tests-ex/cases/cluster/Common/environment-configs/overlord.env b/integration-tests-ex/cases/cluster/Common/environment-configs/overlord.env
index 0d92fe9e09d4..5e8b6a809cc9 100644
--- a/integration-tests-ex/cases/cluster/Common/environment-configs/overlord.env
+++ b/integration-tests-ex/cases/cluster/Common/environment-configs/overlord.env
@@ -29,5 +29,5 @@ druid_indexer_runner_type=remote
 druid_auth_basic_common_cacheDirectory=/tmp/authCache/overlord
 druid_server_https_crlPath=/tls/revocations.crl
 
-druid_segments_manager_pollDuration=PT5S
-druid_segments_manager_useCache=true
+druid_manager_segments_pollDuration=PT5S
+druid_manager_segments_useCache=always
diff --git a/integration-tests/docker/environment-configs/overlord b/integration-tests/docker/environment-configs/overlord
index 1f3e7fcb602e..df351c73d278 100644
--- a/integration-tests/docker/environment-configs/overlord
+++ b/integration-tests/docker/environment-configs/overlord
@@ -33,5 +33,5 @@ druid_indexer_storage_type=metadata
 druid_indexer_runner_type=remote
 druid_auth_basic_common_cacheDirectory=/tmp/authCache/overlord
 druid_server_https_crlPath=/tls/revocations.crl
-druid_segments_manager_pollDuration=PT2S
-druid_segments_manager_useCache=true
+druid_manager_segments_pollDuration=PT5S
+druid_manager_segments_useCache=always
diff --git a/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java b/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java
index b4682e2be5a3..2f35c9f45d47 100644
--- a/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java
+++ b/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java
@@ -174,7 +174,7 @@ private Set<DataSegment> doRetrieveUsedSegments(
       final Segments visibility
   )
   {
-    return inReadWriteDatasourceTransaction(
+    return inReadOnlyDatasourceTransaction(
         dataSource,
         transaction -> {
           if (visibility == Segments.ONLY_VISIBLE) {
@@ -283,7 +283,7 @@ public int markAllSegmentsAsUnused(String dataSource)
   }
 
   private SegmentTimeline getTimelineForIntervals(
-      final SegmentMetadataTransaction transaction,
+      final SegmentMetadataReadTransaction transaction,
       final List<Interval> intervals
   )
   {
@@ -1500,6 +1500,11 @@ private SegmentIdWithShardSpec getTrueAllocatedId(
         allocatedId.getInterval(),
         allocatedId.getVersion()
     );
+    log.info(
+        "Allocated SegmentId[%s] is already in use. Using next ID after max[%s].",
+        allocatedId.asSegmentId(), unusedMaxId
+    );
+
     // No unused segment. Just return the allocated id
     if (unusedMaxId == null) {
       return allocatedId;
diff --git a/server/src/main/java/org/apache/druid/metadata/SegmentsMetadataManagerConfig.java b/server/src/main/java/org/apache/druid/metadata/SegmentsMetadataManagerConfig.java
index fc65de4af532..033a703247fa 100644
--- a/server/src/main/java/org/apache/druid/metadata/SegmentsMetadataManagerConfig.java
+++ b/server/src/main/java/org/apache/druid/metadata/SegmentsMetadataManagerConfig.java
@@ -22,6 +22,7 @@
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import org.apache.druid.common.config.Configs;
+import org.apache.druid.metadata.segment.cache.SegmentMetadataCache;
 import org.joda.time.Period;
 
 /**
@@ -36,19 +37,19 @@ public class SegmentsMetadataManagerConfig
   private final Period pollDuration;
 
   @JsonProperty
-  private final boolean useCache;
+  private final SegmentMetadataCache.UsageMode useCache;
 
   @JsonCreator
   public SegmentsMetadataManagerConfig(
       @JsonProperty("pollDuration") Period pollDuration,
-      @JsonProperty("useCache") Boolean useCache
+      @JsonProperty("useCache") SegmentMetadataCache.UsageMode useCache
   )
   {
     this.pollDuration = Configs.valueOrDefault(pollDuration, Period.minutes(1));
-    this.useCache = Configs.valueOrDefault(useCache, false);
+    this.useCache = Configs.valueOrDefault(useCache, SegmentMetadataCache.UsageMode.NEVER);
   }
 
-  public boolean isUseCache()
+  public SegmentMetadataCache.UsageMode getCacheMode()
   {
     return useCache;
   }
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/CachedSegmentMetadataTransaction.java b/server/src/main/java/org/apache/druid/metadata/segment/CachedSegmentMetadataTransaction.java
index b6f21b301f09..3d19d7c7365e 100644
--- a/server/src/main/java/org/apache/druid/metadata/segment/CachedSegmentMetadataTransaction.java
+++ b/server/src/main/java/org/apache/druid/metadata/segment/CachedSegmentMetadataTransaction.java
@@ -60,21 +60,34 @@ class CachedSegmentMetadataTransaction implements SegmentMetadataTransaction
   private final DruidLeaderSelector leaderSelector;
 
   private final int startTerm;
+  private final boolean readFromCache;
 
   private boolean isRollingBack = false;
   private boolean isClosed = false;
 
   private final List<Consumer<DatasourceSegmentMetadataWriter>> pendingCacheWrites = new ArrayList<>();
 
+  /**
+   * Creates a transaction that may read or write from the cache or delegate to
+   * the metadata store if necessary. Writes are always done to the cache unless
+   * the update does not affect the cache contents.
+   *
+   * @param leaderSelector Used to ensure that leadership does not change during
+   *                       the course of the transaction.
+   * @param readFromCache  If true, reads are done from cache. Otherwise,
+   *                       reads are done directly from the metadata store.
+   */
   CachedSegmentMetadataTransaction(
       SegmentMetadataTransaction delegate,
       DatasourceSegmentCache metadataCache,
-      DruidLeaderSelector leaderSelector
+      DruidLeaderSelector leaderSelector,
+      boolean readFromCache
   )
   {
     this.delegate = delegate;
     this.metadataCache = metadataCache;
     this.leaderSelector = leaderSelector;
+    this.readFromCache = readFromCache;
 
     if (leaderSelector.isLeader()) {
       this.startTerm = leaderSelector.localTerm();
@@ -147,11 +160,16 @@ public Set<String> findExistingSegmentIds(Set<SegmentId> segmentIds)
     final Set<SegmentId> remainingIdsToFind = new HashSet<>(segmentIds);
 
     // Try to find IDs in cache
-    final Set<String> foundIds = metadataCache.findUsedSegments(remainingIdsToFind)
-                                              .stream()
-                                              .map(segment -> segment.getDataSegment().getId().toString())
-                                              .collect(Collectors.toCollection(HashSet::new));
-    remainingIdsToFind.removeIf(id -> foundIds.contains(id.toString()));
+    final Set<String> foundIds = new HashSet<>();
+    if (readFromCache) {
+      foundIds.addAll(
+          metadataCache.findUsedSegments(remainingIdsToFind)
+                       .stream()
+                       .map(segment -> segment.getDataSegment().getId().toString())
+                       .collect(Collectors.toCollection(HashSet::new))
+      );
+      remainingIdsToFind.removeIf(id -> foundIds.contains(id.toString()));
+    }
 
     // Find remaining IDs in metadata store
     if (!remainingIdsToFind.isEmpty()) {
@@ -166,7 +184,7 @@ public Set<String> findExistingSegmentIds(Set<SegmentId> segmentIds)
   @Override
   public Set<SegmentId> findUsedSegmentIdsOverlapping(Interval interval)
   {
-    return metadataCache.findUsedSegmentIdsOverlapping(interval);
+    return performReadAction(reader -> reader.findUsedSegmentIdsOverlapping(interval));
   }
 
   @Override
@@ -182,15 +200,20 @@ public List<DataSegmentPlus> findSegments(Set<SegmentId> segmentIds)
     final Set<SegmentId> remainingIdsToFind = new HashSet<>(segmentIds);
 
     // Try to find segments in cache
-    final List<DataSegmentPlus> foundSegments = new ArrayList<>(
-        metadataCache.findUsedSegments(remainingIdsToFind)
-    );
-    foundSegments.forEach(segment -> remainingIdsToFind.remove(segment.getDataSegment().getId()));
+    final List<DataSegmentPlus> foundSegments = new ArrayList<>();
+    if (readFromCache) {
+      foundSegments.addAll(
+          metadataCache.findUsedSegments(remainingIdsToFind)
+      );
+      foundSegments.forEach(segment -> remainingIdsToFind.remove(segment.getDataSegment().getId()));
+    }
 
     // Find remaining segments in metadata store
-    foundSegments.addAll(
-        delegate.findSegments(remainingIdsToFind)
-    );
+    if (!remainingIdsToFind.isEmpty()) {
+      foundSegments.addAll(
+          delegate.findSegments(remainingIdsToFind)
+      );
+    }
 
     return List.copyOf(foundSegments);
   }
@@ -205,19 +228,19 @@ public List<DataSegmentPlus> findSegmentsWithSchema(Set<SegmentId> segmentIds)
   @Override
   public Set<DataSegment> findUsedSegmentsOverlappingAnyOf(List<Interval> intervals)
   {
-    return metadataCache.findUsedSegmentsOverlappingAnyOf(intervals);
+    return performReadAction(reader -> reader.findUsedSegmentsOverlappingAnyOf(intervals));
   }
 
   @Override
   public List<DataSegmentPlus> findUsedSegments(Set<SegmentId> segmentIds)
   {
-    return metadataCache.findUsedSegments(segmentIds);
+    return performReadAction(reader -> reader.findUsedSegments(segmentIds));
   }
 
   @Override
   public Set<DataSegmentPlus> findUsedSegmentsPlusOverlappingAnyOf(List<Interval> intervals)
   {
-    return metadataCache.findUsedSegmentsPlusOverlappingAnyOf(intervals);
+    return performReadAction(reader -> reader.findUsedSegmentsPlusOverlappingAnyOf(intervals));
   }
 
   @Override
@@ -248,7 +271,7 @@ public DataSegment findSegment(SegmentId segmentId)
   @Override
   public DataSegment findUsedSegment(SegmentId segmentId)
   {
-    return metadataCache.findUsedSegment(segmentId);
+    return performReadAction(reader -> reader.findUsedSegment(segmentId));
   }
 
   @Override
@@ -257,7 +280,7 @@ public List<SegmentIdWithShardSpec> findPendingSegmentIds(
       String sequencePreviousId
   )
   {
-    return metadataCache.findPendingSegmentIds(sequenceName, sequencePreviousId);
+    return performReadAction(reader -> reader.findPendingSegmentIds(sequenceName, sequencePreviousId));
   }
 
   @Override
@@ -266,25 +289,25 @@ public List<SegmentIdWithShardSpec> findPendingSegmentIdsWithExactInterval(
       Interval interval
   )
   {
-    return metadataCache.findPendingSegmentIdsWithExactInterval(sequenceName, interval);
+    return performReadAction(reader -> reader.findPendingSegmentIdsWithExactInterval(sequenceName, interval));
   }
 
   @Override
   public List<PendingSegmentRecord> findPendingSegmentsOverlapping(Interval interval)
   {
-    return metadataCache.findPendingSegmentsOverlapping(interval);
+    return performReadAction(reader -> reader.findPendingSegmentsOverlapping(interval));
   }
 
   @Override
   public List<PendingSegmentRecord> findPendingSegmentsWithExactInterval(Interval interval)
   {
-    return metadataCache.findPendingSegmentsWithExactInterval(interval);
+    return performReadAction(reader -> reader.findPendingSegmentsWithExactInterval(interval));
   }
 
   @Override
   public List<PendingSegmentRecord> findPendingSegments(String taskAllocatorId)
   {
-    return metadataCache.findPendingSegments(taskAllocatorId);
+    return performReadAction(reader -> reader.findPendingSegments(taskAllocatorId));
   }
 
   // WRITE METHODS
@@ -404,6 +427,19 @@ public int deletePendingSegmentsCreatedIn(Interval interval)
     );
   }
 
+  /**
+   * Performs a read from cache only if {@link #readFromCache} is true.
+   * Otherwise, reads directly from the metadata store.
+   */
+  private <T> T performReadAction(Function<DatasourceSegmentMetadataReader, T> action)
+  {
+    if (readFromCache) {
+      return action.apply(metadataCache);
+    } else {
+      return action.apply(delegate);
+    }
+  }
+
   private <T> T performWriteAction(Function<DatasourceSegmentMetadataWriter, T> action)
   {
     if (isClosed) {
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/SqlSegmentMetadataTransactionFactory.java b/server/src/main/java/org/apache/druid/metadata/segment/SqlSegmentMetadataTransactionFactory.java
index 0d8b707bded5..71974872a237 100644
--- a/server/src/main/java/org/apache/druid/metadata/segment/SqlSegmentMetadataTransactionFactory.java
+++ b/server/src/main/java/org/apache/druid/metadata/segment/SqlSegmentMetadataTransactionFactory.java
@@ -23,10 +23,15 @@
 import com.google.inject.Inject;
 import org.apache.druid.client.indexing.IndexingService;
 import org.apache.druid.discovery.DruidLeaderSelector;
+import org.apache.druid.java.util.common.logger.Logger;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceMetricEvent;
 import org.apache.druid.metadata.MetadataStorageTablesConfig;
 import org.apache.druid.metadata.SQLMetadataConnector;
 import org.apache.druid.metadata.segment.cache.DatasourceSegmentCache;
+import org.apache.druid.metadata.segment.cache.Metric;
 import org.apache.druid.metadata.segment.cache.SegmentMetadataCache;
+import org.apache.druid.query.DruidMetrics;
 import org.skife.jdbi.v2.Handle;
 import org.skife.jdbi.v2.TransactionStatus;
 
@@ -40,6 +45,8 @@
  */
 public class SqlSegmentMetadataTransactionFactory implements SegmentMetadataTransactionFactory
 {
+  private static final Logger log = new Logger(SqlSegmentMetadataTransactionFactory.class);
+
   private static final int QUIET_RETRIES = 2;
   private static final int MAX_RETRIES = 3;
 
@@ -48,6 +55,7 @@ public class SqlSegmentMetadataTransactionFactory implements SegmentMetadataTran
   private final SQLMetadataConnector connector;
   private final DruidLeaderSelector leaderSelector;
   private final SegmentMetadataCache segmentMetadataCache;
+  private final ServiceEmitter emitter;
 
   @Inject
   public SqlSegmentMetadataTransactionFactory(
@@ -55,7 +63,8 @@ public SqlSegmentMetadataTransactionFactory(
       MetadataStorageTablesConfig tablesConfig,
       SQLMetadataConnector connector,
       @IndexingService DruidLeaderSelector leaderSelector,
-      SegmentMetadataCache segmentMetadataCache
+      SegmentMetadataCache segmentMetadataCache,
+      ServiceEmitter emitter
   )
   {
     this.jsonMapper = jsonMapper;
@@ -63,6 +72,7 @@ public SqlSegmentMetadataTransactionFactory(
     this.connector = connector;
     this.leaderSelector = leaderSelector;
     this.segmentMetadataCache = segmentMetadataCache;
+    this.emitter = emitter;
   }
 
   public int getMaxRetries()
@@ -81,12 +91,14 @@ public <T> T inReadOnlyDatasourceTransaction(
           final SegmentMetadataTransaction sqlTransaction
               = createSqlTransaction(dataSource, handle, status);
 
-          if (segmentMetadataCache.isEnabled()) {
+          // For read-only transactions, use cache only if it is already synced
+          if (segmentMetadataCache.isSyncedForRead()) {
             final DatasourceSegmentCache datasourceCache
                 = segmentMetadataCache.getDatasource(dataSource);
             final SegmentMetadataReadTransaction cachedTransaction
-                = new CachedSegmentMetadataTransaction(sqlTransaction, datasourceCache, leaderSelector);
+                = new CachedSegmentMetadataTransaction(sqlTransaction, datasourceCache, leaderSelector, true);
 
+            emitTransactionCount(Metric.READ_ONLY_TRANSACTIONS, dataSource);
             return datasourceCache.read(() -> executeReadAndClose(cachedTransaction, callback));
           } else {
             return executeReadAndClose(sqlTransaction, callback);
@@ -109,10 +121,26 @@ public <T> T inReadWriteDatasourceTransaction(
               = createSqlTransaction(dataSource, handle, status);
 
           if (segmentMetadataCache.isEnabled()) {
+            final boolean isCacheReadyForRead = segmentMetadataCache.isSyncedForRead();
             final DatasourceSegmentCache datasourceCache
                 = segmentMetadataCache.getDatasource(dataSource);
-            final SegmentMetadataTransaction cachedTransaction
-                = new CachedSegmentMetadataTransaction(sqlTransaction, datasourceCache, leaderSelector);
+            final SegmentMetadataTransaction cachedTransaction = new CachedSegmentMetadataTransaction(
+                sqlTransaction,
+                datasourceCache,
+                leaderSelector,
+                isCacheReadyForRead
+            );
+
+            if (isCacheReadyForRead) {
+              emitTransactionCount(Metric.READ_WRITE_TRANSACTIONS, dataSource);
+            } else {
+              log.warn(
+                  "Starting read-write transaction for datasource[%s]. Reads will be done"
+                  + " directly from metadata store since cache is not synced yet.",
+                  dataSource
+              );
+              emitTransactionCount(Metric.WRITE_ONLY_TRANSACTIONS, dataSource);
+            }
 
             return datasourceCache.write(() -> executeWriteAndClose(cachedTransaction, callback));
           } else {
@@ -163,4 +191,13 @@ private <T> T executeReadAndClose(
     }
   }
 
+  private void emitTransactionCount(String metricName, String datasource)
+  {
+    emitter.emit(
+        ServiceMetricEvent.builder()
+                          .setDimension(DruidMetrics.DATASOURCE, datasource)
+                          .setMetric(metricName, 1L)
+    );
+  }
+
 }
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCache.java b/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCache.java
index b51f1e026a0a..d9210b782afd 100644
--- a/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCache.java
+++ b/server/src/main/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCache.java
@@ -64,18 +64,21 @@
 import java.util.concurrent.CancellationException;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 
 /**
  * In-memory implementation of {@link SegmentMetadataCache}.
  * <p>
- * Only used segments (excluding num_rows and schema_fingerpring) and
+ * Only used segments (excluding num_rows and schema_fingerprint) and
  * pending segments are cached. Unused segments are not cached.
  * <p>
  * Non-leader Overlords also keep polling the metadata store to keep the cache
  * up-to-date in case leadership changes.
  * <p>
+ * For cache usage modes, see {@link UsageMode}.
+ * <p>
  * The map {@link #datasourceToSegmentCache} contains the cache for each datasource.
  * Items are only added to this map and never removed. This is to avoid handling
  * race conditions where a thread has invoked {@link #getDatasource} but hasn't
@@ -105,7 +108,7 @@ private enum CacheState
 
   private final ObjectMapper jsonMapper;
   private final Duration pollDuration;
-  private final boolean isCacheEnabled;
+  private final UsageMode cacheMode;
   private final MetadataStorageTablesConfig tablesConfig;
   private final SQLMetadataConnector connector;
 
@@ -114,6 +117,13 @@ private enum CacheState
 
   private final Object cacheStateLock = new Object();
 
+  /**
+   * Denotes that the cache is in state {@link CacheState#LEADER_READY}.
+   * Maintained as a separate variable to avoid acquiring the {@link #cacheStateLock}
+   * whenever {@link #isSyncedForRead()} is checked in a transaction.
+   */
+  private final AtomicBoolean isCacheReady = new AtomicBoolean(false);
+
   @GuardedBy("cacheStateLock")
   private CacheState currentCacheState = CacheState.STOPPED;
   @GuardedBy("cacheStateLock")
@@ -137,11 +147,11 @@ public HeapMemorySegmentMetadataCache(
   )
   {
     this.jsonMapper = jsonMapper;
-    this.isCacheEnabled = config.get().isUseCache();
+    this.cacheMode = config.get().getCacheMode();
     this.pollDuration = config.get().getPollDuration().toStandardDuration();
     this.tablesConfig = tablesConfig.get();
     this.connector = connector;
-    this.pollExecutor = isCacheEnabled
+    this.pollExecutor = isEnabled()
                         ? MoreExecutors.listeningDecorator(executorFactory.create(1, "SegmentMetadataCache-%s"))
                         : null;
     this.emitter = emitter;
@@ -151,7 +161,7 @@ public HeapMemorySegmentMetadataCache(
   @Override
   public void start()
   {
-    if (!isCacheEnabled) {
+    if (!isEnabled()) {
       log.info("Segment metadata cache is not enabled.");
       return;
     }
@@ -159,8 +169,28 @@ public void start()
     synchronized (cacheStateLock) {
       if (currentCacheState == CacheState.STOPPED) {
         updateCacheState(CacheState.FOLLOWER, "Scheduling sync with metadata store");
-        scheduleSyncWithMetadataStore(pollDuration.getMillis());
       }
+
+      if (cacheMode == UsageMode.ALWAYS) {
+        // Cache must always be used, do not finish startup until cache has synced
+        performFirstSync();
+      }
+
+      scheduleSyncWithMetadataStore(pollDuration.getMillis());
+    }
+  }
+
+  private void performFirstSync()
+  {
+    try {
+      log.info("Cache is in usage mode[%s]. Starting first sync with metadata store.", cacheMode);
+
+      final long syncDurationMillis = syncWithMetadataStore();
+      emitMetric(Metric.SYNC_DURATION_MILLIS, syncDurationMillis);
+      log.info("Finished first sync of cache with metadata store in [%d] millis.", syncDurationMillis);
+    }
+    catch (Throwable t) {
+      throw InternalServerError.exception(t, "Could not sync segment metadata cache with metadata store");
     }
   }
 
@@ -168,7 +198,7 @@ public void start()
   public void stop()
   {
     synchronized (cacheStateLock) {
-      if (isCacheEnabled) {
+      if (isEnabled()) {
         pollExecutor.shutdownNow();
         datasourceToSegmentCache.forEach((datasource, cache) -> cache.stop());
         datasourceToSegmentCache.clear();
@@ -183,7 +213,7 @@ public void stop()
   public void becomeLeader()
   {
     synchronized (cacheStateLock) {
-      if (isCacheEnabled) {
+      if (isEnabled()) {
         if (currentCacheState == CacheState.STOPPED) {
           throw DruidException.defensive("Cache has not been started yet");
         } else {
@@ -202,7 +232,7 @@ public void becomeLeader()
   public void stopBeingLeader()
   {
     synchronized (cacheStateLock) {
-      if (isCacheEnabled) {
+      if (isEnabled()) {
         updateCacheState(CacheState.FOLLOWER, "Not leader anymore");
       }
     }
@@ -211,14 +241,19 @@ public void stopBeingLeader()
   @Override
   public boolean isEnabled()
   {
-    return isCacheEnabled;
+    return cacheMode != UsageMode.NEVER;
+  }
+
+  @Override
+  public boolean isSyncedForRead()
+  {
+    return isEnabled() && isCacheReady.get();
   }
 
   @Override
   public DatasourceSegmentCache getDatasource(String dataSource)
   {
     verifyCacheIsUsableAndAwaitSync();
-    emitMetric(dataSource, Metric.TRANSACTION_COUNT, 1);
     return getCacheForDatasource(dataSource);
   }
 
@@ -229,13 +264,14 @@ private HeapMemoryDatasourceSegmentCache getCacheForDatasource(String dataSource
 
   /**
    * Verifies that the cache is enabled, started and has become leader.
-   * Also waits for the cache to be synced with metadata store.
+   * Also waits for the cache to be synced with the metadata store after becoming
+   * leader if {@link #cacheMode} is set to {@link UsageMode#ALWAYS}.
    *
    * @throws DruidException if the cache is disabled, stopped or not leader.
    */
   private void verifyCacheIsUsableAndAwaitSync()
   {
-    if (!isCacheEnabled) {
+    if (!isEnabled()) {
       throw DruidException.defensive("Segment metadata cache is not enabled.");
     }
 
@@ -247,8 +283,10 @@ private void verifyCacheIsUsableAndAwaitSync()
           throw InternalServerError.exception("Not leader yet. Segment metadata cache is not usable.");
         case LEADER_FIRST_SYNC_PENDING:
         case LEADER_FIRST_SYNC_STARTED:
-          waitForCacheToFinishSync();
-          verifyCacheIsUsableAndAwaitSync();
+          if (cacheMode == UsageMode.ALWAYS) {
+            waitForCacheToFinishSync();
+            verifyCacheIsUsableAndAwaitSync();
+          }
         case LEADER_READY:
           // Cache is now ready for use
       }
@@ -287,10 +325,10 @@ private void updateCacheState(CacheState targetState, String message)
       currentCacheState = targetState;
       log.info("%s. Cache is now in state[%s].", message, currentCacheState);
 
-      // Notify threads waiting for cache to be ready
-      if (currentCacheState == CacheState.LEADER_READY) {
-        cacheStateLock.notifyAll();
-      }
+      isCacheReady.set(currentCacheState == CacheState.LEADER_READY);
+
+      // Notify threads waiting for cache to change state
+      cacheStateLock.notifyAll();
     }
   }
 
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/cache/Metric.java b/server/src/main/java/org/apache/druid/metadata/segment/cache/Metric.java
index 7e5e5485c5d8..ea22a5fb7116 100644
--- a/server/src/main/java/org/apache/druid/metadata/segment/cache/Metric.java
+++ b/server/src/main/java/org/apache/druid/metadata/segment/cache/Metric.java
@@ -43,9 +43,19 @@ private Metric()
   private static final String METRIC_NAME_PREFIX = "segment/metadataCache/";
 
   /**
-   * Number of transactions performed on the cache for a datasource.
+   * Number of read-write transactions performed on the cache for a datasource.
    */
-  public static final String TRANSACTION_COUNT = METRIC_NAME_PREFIX + "transactions";
+  public static final String READ_WRITE_TRANSACTIONS = METRIC_NAME_PREFIX + "transactions/readWrite";
+
+  /**
+   * Number of write-only transactions performed on the cache for a datasource.
+   */
+  public static final String WRITE_ONLY_TRANSACTIONS = METRIC_NAME_PREFIX + "transactions/writeOnly";
+
+  /**
+   * Number of read-only transactions performed on the cache for a datasource.
+   */
+  public static final String READ_ONLY_TRANSACTIONS = METRIC_NAME_PREFIX + "transactions/readOnly";
 
   /**
    * Total number of distinct intervals currently present in the cache.
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/cache/NoopSegmentMetadataCache.java b/server/src/main/java/org/apache/druid/metadata/segment/cache/NoopSegmentMetadataCache.java
index 080464b44605..88e2cf05e3b6 100644
--- a/server/src/main/java/org/apache/druid/metadata/segment/cache/NoopSegmentMetadataCache.java
+++ b/server/src/main/java/org/apache/druid/metadata/segment/cache/NoopSegmentMetadataCache.java
@@ -21,6 +21,13 @@
 
 public class NoopSegmentMetadataCache implements SegmentMetadataCache
 {
+  private static final NoopSegmentMetadataCache INSTANCE = new NoopSegmentMetadataCache();
+
+  public static NoopSegmentMetadataCache instance()
+  {
+    return INSTANCE;
+  }
+
   @Override
   public void start()
   {
@@ -51,6 +58,12 @@ public boolean isEnabled()
     return false;
   }
 
+  @Override
+  public boolean isSyncedForRead()
+  {
+    return false;
+  }
+
   @Override
   public DatasourceSegmentCache getDatasource(String dataSource)
   {
diff --git a/server/src/main/java/org/apache/druid/metadata/segment/cache/SegmentMetadataCache.java b/server/src/main/java/org/apache/druid/metadata/segment/cache/SegmentMetadataCache.java
index af0b17f696f2..2fa501c7a123 100644
--- a/server/src/main/java/org/apache/druid/metadata/segment/cache/SegmentMetadataCache.java
+++ b/server/src/main/java/org/apache/druid/metadata/segment/cache/SegmentMetadataCache.java
@@ -19,6 +19,9 @@
 
 package org.apache.druid.metadata.segment.cache;
 
+import com.fasterxml.jackson.annotation.JsonCreator;
+import org.apache.druid.error.InvalidInput;
+
 /**
  * Cache for metadata of pending segments and committed segments maintained by
  * the Overlord to improve performance of segment allocation and other task actions.
@@ -54,9 +57,66 @@ public interface SegmentMetadataCache
    */
   boolean isEnabled();
 
+  /**
+   * @return true if the cache is enabled and synced with the metadata store.
+   * Reads can be done from the cache only if it is synced but writes can happen
+   * even before the sync has finished.
+   */
+  boolean isSyncedForRead();
+
   /**
    * Returns the cache for the given datasource.
    */
   DatasourceSegmentCache getDatasource(String dataSource);
 
+  /**
+   * Cache usage modes.
+   */
+  enum UsageMode
+  {
+    /**
+     * Always read from the cache. Service start-up may be blocked until cache
+     * has synced with the metadata store at least once. Transactions may block
+     * until cache has synced with the metadata store at least once after
+     * becoming leader.
+     */
+    ALWAYS("always"),
+
+    /**
+     * Cache is disabled.
+     */
+    NEVER("never"),
+
+    /**
+     * Read from the cache only if it is already synced with the metadata store.
+     * Does not block service start-up or transactions. Writes may still go to
+     * cache to reduce sync times.
+     */
+    IF_SYNCED("ifSynced");
+
+    private final String name;
+
+    UsageMode(String name)
+    {
+      this.name = name;
+    }
+
+    @JsonCreator
+    public static UsageMode fromString(String value)
+    {
+      for (UsageMode mode : values()) {
+        if (mode.toString().equals(value)) {
+          return mode;
+        }
+      }
+
+      throw InvalidInput.exception("No such cache usage mode[%s]", value);
+    }
+
+    @Override
+    public String toString()
+    {
+      return name;
+    }
+  }
 }
diff --git a/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java b/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java
index 71e92fc31787..6671fe4e1332 100644
--- a/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java
+++ b/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java
@@ -37,7 +37,7 @@
 import org.apache.druid.metadata.segment.SegmentMetadataTransaction;
 import org.apache.druid.metadata.segment.SqlSegmentMetadataTransactionFactory;
 import org.apache.druid.metadata.segment.cache.HeapMemorySegmentMetadataCache;
-import org.apache.druid.metadata.segment.cache.NoopSegmentMetadataCache;
+import org.apache.druid.metadata.segment.cache.Metric;
 import org.apache.druid.metadata.segment.cache.SegmentMetadataCache;
 import org.apache.druid.segment.SegmentSchemaMapping;
 import org.apache.druid.segment.TestDataSource;
@@ -90,6 +90,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
 @RunWith(Parameterized.class)
@@ -104,17 +105,21 @@ public class IndexerSQLMetadataStorageCoordinatorTest extends IndexerSqlMetadata
   private SqlSegmentMetadataTransactionFactory transactionFactory;
   private BlockingExecutorService cachePollExecutor;
 
-  private final boolean useSegmentCache;
+  private final SegmentMetadataCache.UsageMode cacheMode;
 
-  @Parameterized.Parameters(name = "useSegmentCache = {0}")
+  @Parameterized.Parameters(name = "cacheMode = {0}")
   public static Object[][] testParameters()
   {
-    return new Object[][]{{true}, {false}};
+    return new Object[][]{
+        {SegmentMetadataCache.UsageMode.ALWAYS},
+        {SegmentMetadataCache.UsageMode.NEVER},
+        {SegmentMetadataCache.UsageMode.IF_SYNCED}
+    };
   }
 
-  public IndexerSQLMetadataStorageCoordinatorTest(boolean useSegmentCache)
+  public IndexerSQLMetadataStorageCoordinatorTest(SegmentMetadataCache.UsageMode cacheMode)
   {
-    this.useSegmentCache = useSegmentCache;
+    this.cacheMode = cacheMode;
   }
 
   @Before
@@ -139,9 +144,10 @@ public void setUp()
     leaderSelector = new TestDruidLeaderSelector();
 
     cachePollExecutor = new BlockingExecutorService("test-cache-poll-exec");
+
     segmentMetadataCache = new HeapMemorySegmentMetadataCache(
         mapper,
-        () -> new SegmentsMetadataManagerConfig(null, useSegmentCache),
+        () -> new SegmentsMetadataManagerConfig(null, cacheMode),
         derbyConnectorRule.metadataTablesConfigSupplier(),
         derbyConnector,
         (corePoolSize, nameFormat) -> new WrappingScheduledExecutorService(
@@ -155,10 +161,11 @@ public void setUp()
     leaderSelector.becomeLeader();
 
     // Get the cache ready if required
-    if (useSegmentCache) {
+    if (isCacheEnabled()) {
       segmentMetadataCache.start();
       segmentMetadataCache.becomeLeader();
-      cachePollExecutor.finishNextPendingTasks(4);
+      refreshCache();
+      refreshCache();
     }
 
     transactionFactory = new SqlSegmentMetadataTransactionFactory(
@@ -166,7 +173,8 @@ public void setUp()
         derbyConnectorRule.metadataTablesConfigSupplier().get(),
         derbyConnector,
         leaderSelector,
-        segmentMetadataCache
+        segmentMetadataCache,
+        emitter
     )
     {
       @Override
@@ -207,12 +215,17 @@ public void tearDown()
     leaderSelector.stopBeingLeader();
   }
 
-  void refreshCache()
+  private void refreshCache()
   {
-    if (useSegmentCache) {
+    if (isCacheEnabled()) {
       cachePollExecutor.finishNextPendingTasks(2);
     }
   }
+  
+  private boolean isCacheEnabled()
+  {
+    return cacheMode != SegmentMetadataCache.UsageMode.NEVER;
+  }
 
   @Test
   public void testCommitAppendSegments()
@@ -764,13 +777,7 @@ public void testTransactionalAnnounceRetryAndSuccess() throws IOException
     final AtomicLong attemptCounter = new AtomicLong();
 
     final IndexerSQLMetadataStorageCoordinator failOnceCoordinator = new IndexerSQLMetadataStorageCoordinator(
-        new SqlSegmentMetadataTransactionFactory(
-            mapper,
-            derbyConnectorRule.metadataTablesConfigSupplier().get(),
-            derbyConnector,
-            new TestDruidLeaderSelector(),
-            new NoopSegmentMetadataCache()
-        ),
+        transactionFactory,
         mapper,
         derbyConnectorRule.metadataTablesConfigSupplier().get(),
         derbyConnector,
@@ -936,6 +943,8 @@ public void testRetrieveSegmentForId()
   @Test
   public void testCleanUpgradeSegmentsTableForTask()
   {
+    Assume.assumeFalse(isCacheEnabled());
+
     final String taskToClean = "taskToClean";
     final ReplaceTaskLock replaceLockToClean = new ReplaceTaskLock(
         taskToClean,
@@ -2179,7 +2188,7 @@ public void testSecondHalfEternitySegmentWithStringComparison()
   public void testLargeIntervalWithStringComparison()
   {
     // Known Issue when not using cache: https://github.com/apache/druid/issues/12860
-    Assume.assumeTrue(useSegmentCache);
+    Assume.assumeTrue(isCacheEnabled());
 
     coordinator.commitSegments(
         ImmutableSet.of(
@@ -2280,7 +2289,7 @@ public void testDeleteSegmentsInMetaDataStorage()
   @Test
   public void testUpdateSegmentsInMetaDataStorage()
   {
-    Assume.assumeFalse(useSegmentCache);
+    Assume.assumeFalse(isCacheEnabled());
 
     // Published segments to MetaDataStorage
     coordinator.commitSegments(SEGMENTS, new SegmentSchemaMapping(CentralizedDatasourceSchemaConfig.SCHEMA_VERSION));
@@ -3711,6 +3720,8 @@ public void testRetrieveUpgradedFromSegmentIds()
   @Test
   public void testRetrieveUpgradedFromSegmentIdsInBatches()
   {
+    Assume.assumeFalse(isCacheEnabled());
+
     final int size = 500;
     final int batchSize = 100;
 
@@ -3909,7 +3920,7 @@ public void testRetrieveUsedSegmentsForSegmentAllocation()
   @Test
   public void testCachedTransaction_cannotReadWhatItWrites()
   {
-    Assume.assumeTrue(useSegmentCache);
+    Assume.assumeTrue(isCacheEnabled());
 
     transactionFactory.inReadWriteDatasourceTransaction(
         TestDataSource.WIKI,
@@ -3930,6 +3941,92 @@ public void testCachedTransaction_cannotReadWhatItWrites()
           return 0;
         }
     );
+
+    emitter.verifyValue(Metric.READ_WRITE_TRANSACTIONS, 1L);
+  }
+
+  @Test
+  public void testReadOperation_usesCache_ifSynced()
+  {
+    Assume.assumeTrue(isCacheEnabled());
+
+    Assert.assertTrue(segmentMetadataCache.isSyncedForRead());
+
+    insertUsedSegments(Set.of(defaultSegment), Map.of());
+    final Supplier<Set<DataSegment>> retrieveAction =
+        () -> coordinator.retrieveAllUsedSegments(
+            defaultSegment.getDataSource(),
+            Segments.INCLUDING_OVERSHADOWED
+        );
+
+    // Retrieve returns empty since cache is not synced with metadata store yet
+    Assert.assertTrue(retrieveAction.get().isEmpty());
+
+    refreshCache();
+    Assert.assertEquals(Set.of(defaultSegment), retrieveAction.get());
+
+    emitter.verifyEmitted(Metric.READ_ONLY_TRANSACTIONS, 2);
+  }
+
+  @Test
+  public void testReadOperation_doesNotUseCache_ifNotSynced()
+  {
+    Assume.assumeTrue(isCacheEnabled());
+
+    segmentMetadataCache.stopBeingLeader();
+    Assert.assertFalse(segmentMetadataCache.isSyncedForRead());
+
+    final Supplier<Set<DataSegment>> retrieveAction =
+        () -> coordinator.retrieveAllUsedSegments(
+            defaultSegment.getDataSource(),
+            Segments.INCLUDING_OVERSHADOWED
+        );
+
+    insertUsedSegments(Set.of(defaultSegment), Map.of());
+
+    Assert.assertEquals(Set.of(defaultSegment), retrieveAction.get());
+    emitter.verifyNotEmitted(Metric.READ_ONLY_TRANSACTIONS);
+
+    // Become leader but cache will still not be used
+    segmentMetadataCache.becomeLeader();
+    Assert.assertFalse(segmentMetadataCache.isSyncedForRead());
+    Assert.assertEquals(Set.of(defaultSegment), retrieveAction.get());
+    emitter.verifyNotEmitted(Metric.READ_ONLY_TRANSACTIONS);
+
+    // Sync the cache so that it becomes ready for use
+    refreshCache();
+    refreshCache();
+    Assert.assertTrue(segmentMetadataCache.isSyncedForRead());
+    Assert.assertEquals(Set.of(defaultSegment), retrieveAction.get());
+    emitter.verifyValue(Metric.READ_ONLY_TRANSACTIONS, 1L);
+  }
+
+  @Test
+  public void testWriteOperation_alwaysUsesCache_inModeIfSynced()
+  {
+    Assume.assumeTrue(cacheMode == SegmentMetadataCache.UsageMode.IF_SYNCED);
+
+    // Lose and regain leadership
+    segmentMetadataCache.stopBeingLeader();
+    segmentMetadataCache.becomeLeader();
+
+    Assert.assertTrue(segmentMetadataCache.isEnabled());
+    Assert.assertFalse(segmentMetadataCache.isSyncedForRead());
+
+    final Supplier<Set<DataSegment>> writeAction =
+        () -> coordinator.commitSegments(Set.of(defaultSegment), null);
+
+    // Cache is not synced yet and will be used only for write operations
+    Assert.assertEquals(Set.of(defaultSegment), writeAction.get());
+    emitter.verifyValue(Metric.WRITE_ONLY_TRANSACTIONS, 1L);
+
+    // Sync the cache to use it for both read and write operations
+    refreshCache();
+    refreshCache();
+    Assert.assertTrue(segmentMetadataCache.isSyncedForRead());
+
+    Assert.assertTrue(writeAction.get().isEmpty());
+    emitter.verifyValue(Metric.READ_WRITE_TRANSACTIONS, 1L);
   }
 
   private SegmentIdWithShardSpec allocatePendingSegment(
diff --git a/server/src/test/java/org/apache/druid/metadata/IndexerSqlMetadataStorageCoordinatorSchemaPersistenceTest.java b/server/src/test/java/org/apache/druid/metadata/IndexerSqlMetadataStorageCoordinatorSchemaPersistenceTest.java
index c72e1a75afee..c075b7ae8902 100644
--- a/server/src/test/java/org/apache/druid/metadata/IndexerSqlMetadataStorageCoordinatorSchemaPersistenceTest.java
+++ b/server/src/test/java/org/apache/druid/metadata/IndexerSqlMetadataStorageCoordinatorSchemaPersistenceTest.java
@@ -41,6 +41,7 @@
 import org.apache.druid.segment.metadata.SegmentSchemaManager;
 import org.apache.druid.segment.metadata.SegmentSchemaTestUtils;
 import org.apache.druid.server.coordinator.simulate.TestDruidLeaderSelector;
+import org.apache.druid.server.metrics.NoopServiceEmitter;
 import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.partition.HashBasedNumberedShardSpec;
 import org.apache.druid.timeline.partition.LinearShardSpec;
@@ -96,7 +97,8 @@ public void setUp()
         derbyConnectorRule.metadataTablesConfigSupplier().get(),
         derbyConnector,
         new TestDruidLeaderSelector(),
-        new NoopSegmentMetadataCache()
+        NoopSegmentMetadataCache.instance(),
+        NoopServiceEmitter.instance()
     );
     coordinator = new IndexerSQLMetadataStorageCoordinator(
         transactionFactory,
diff --git a/server/src/test/java/org/apache/druid/metadata/SqlSegmentsMetadataManagerSchemaPollTest.java b/server/src/test/java/org/apache/druid/metadata/SqlSegmentsMetadataManagerSchemaPollTest.java
index 834553655570..788de1fa0ffb 100644
--- a/server/src/test/java/org/apache/druid/metadata/SqlSegmentsMetadataManagerSchemaPollTest.java
+++ b/server/src/test/java/org/apache/druid/metadata/SqlSegmentsMetadataManagerSchemaPollTest.java
@@ -54,7 +54,7 @@ public class SqlSegmentsMetadataManagerSchemaPollTest extends SqlSegmentsMetadat
   public void setUp() throws Exception
   {
     connector = derbyConnectorRule.getConnector();
-    SegmentsMetadataManagerConfig config = new SegmentsMetadataManagerConfig(Period.seconds(3), false);
+    SegmentsMetadataManagerConfig config = new SegmentsMetadataManagerConfig(Period.seconds(3), null);
 
     segmentSchemaCache = new SegmentSchemaCache(new NoopServiceEmitter());
     segmentSchemaManager = new SegmentSchemaManager(
@@ -129,7 +129,7 @@ public void testPollSegmentAndSchema()
 
     CentralizedDatasourceSchemaConfig centralizedDatasourceSchemaConfig = new CentralizedDatasourceSchemaConfig();
     centralizedDatasourceSchemaConfig.setEnabled(true);
-    config = new SegmentsMetadataManagerConfig(Period.seconds(3), false);
+    config = new SegmentsMetadataManagerConfig(Period.seconds(3), null);
     sqlSegmentsMetadataManager = new SqlSegmentsMetadataManager(
         jsonMapper,
         Suppliers.ofInstance(config),
@@ -217,7 +217,7 @@ public void testPollOnlyNewSchemaVersion()
 
     CentralizedDatasourceSchemaConfig centralizedDatasourceSchemaConfig = new CentralizedDatasourceSchemaConfig();
     centralizedDatasourceSchemaConfig.setEnabled(true);
-    config = new SegmentsMetadataManagerConfig(Period.seconds(3), false);
+    config = new SegmentsMetadataManagerConfig(Period.seconds(3), null);
     sqlSegmentsMetadataManager = new SqlSegmentsMetadataManager(
         jsonMapper,
         Suppliers.ofInstance(config),
diff --git a/server/src/test/java/org/apache/druid/metadata/SqlSegmentsMetadataManagerTest.java b/server/src/test/java/org/apache/druid/metadata/SqlSegmentsMetadataManagerTest.java
index 1f71a3513a9e..c1f9a0d544f4 100644
--- a/server/src/test/java/org/apache/druid/metadata/SqlSegmentsMetadataManagerTest.java
+++ b/server/src/test/java/org/apache/druid/metadata/SqlSegmentsMetadataManagerTest.java
@@ -110,7 +110,7 @@ private void publishWikiSegments()
   public void setUp()
   {
     connector = derbyConnectorRule.getConnector();
-    SegmentsMetadataManagerConfig config = new SegmentsMetadataManagerConfig(Period.seconds(3), false);
+    SegmentsMetadataManagerConfig config = new SegmentsMetadataManagerConfig(Period.seconds(3), null);
     storageConfig = derbyConnectorRule.metadataTablesConfigSupplier().get();
 
     segmentSchemaCache = new SegmentSchemaCache(NoopServiceEmitter.instance());
@@ -1330,7 +1330,7 @@ public void testIterateAllUsedNonOvershadowedSegmentsForDatasourceInterval() thr
     final Interval theInterval = Intervals.of("2012-03-15T00:00:00.000/2012-03-20T00:00:00.000");
 
     // Re-create SqlSegmentsMetadataManager with a higher poll duration
-    final SegmentsMetadataManagerConfig config = new SegmentsMetadataManagerConfig(Period.seconds(1), false);
+    final SegmentsMetadataManagerConfig config = new SegmentsMetadataManagerConfig(Period.seconds(1), null);
     sqlSegmentsMetadataManager = new SqlSegmentsMetadataManager(
         jsonMapper,
         Suppliers.ofInstance(config),
diff --git a/server/src/test/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCacheTest.java b/server/src/test/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCacheTest.java
index 16710fef591f..89ad8139dea3 100644
--- a/server/src/test/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCacheTest.java
+++ b/server/src/test/java/org/apache/druid/metadata/segment/cache/HeapMemorySegmentMetadataCacheTest.java
@@ -32,7 +32,6 @@
 import org.apache.druid.metadata.PendingSegmentRecord;
 import org.apache.druid.metadata.SegmentsMetadataManagerConfig;
 import org.apache.druid.metadata.TestDerbyConnector;
-import org.apache.druid.query.DruidMetrics;
 import org.apache.druid.segment.TestDataSource;
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
@@ -53,7 +52,6 @@
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
 
 public class HeapMemorySegmentMetadataCacheTest
@@ -95,13 +93,13 @@ public void tearDown()
   /**
    * Creates the target {@link #cache} to be tested in the current test.
    */
-  private void setupTargetWithCaching(boolean enabled)
+  private void setupTargetWithCaching(SegmentMetadataCache.UsageMode cacheMode)
   {
     if (cache != null) {
       throw new ISE("Test target has already been initialized with caching[%s]", cache.isEnabled());
     }
     final SegmentsMetadataManagerConfig metadataManagerConfig
-        = new SegmentsMetadataManagerConfig(null, enabled);
+        = new SegmentsMetadataManagerConfig(null, cacheMode);
     cache = new HeapMemorySegmentMetadataCache(
         TestHelper.JSON_MAPPER,
         () -> metadataManagerConfig,
@@ -114,7 +112,7 @@ private void setupTargetWithCaching(boolean enabled)
 
   private void setupAndSyncCache()
   {
-    setupTargetWithCaching(true);
+    setupTargetWithCaching(SegmentMetadataCache.UsageMode.ALWAYS);
     cache.start();
     cache.becomeLeader();
     syncCacheAfterBecomingLeader();
@@ -134,13 +132,14 @@ private void syncCacheAfterBecomingLeader()
    */
   private void syncCache()
   {
+    serviceEmitter.flush();
     pollExecutor.finishNextPendingTasks(2);
   }
 
   @Test
   public void testStart_schedulesDbPoll_ifCacheIsEnabled()
   {
-    setupTargetWithCaching(true);
+    setupTargetWithCaching(SegmentMetadataCache.UsageMode.ALWAYS);
     Assert.assertTrue(cache.isEnabled());
 
     cache.start();
@@ -155,7 +154,7 @@ public void testStart_schedulesDbPoll_ifCacheIsEnabled()
   @Test
   public void testStart_doesNotScheduleDbPoll_ifCacheIsDisabled()
   {
-    setupTargetWithCaching(false);
+    setupTargetWithCaching(SegmentMetadataCache.UsageMode.NEVER);
     Assert.assertFalse(cache.isEnabled());
 
     cache.start();
@@ -166,7 +165,7 @@ public void testStart_doesNotScheduleDbPoll_ifCacheIsDisabled()
   @Test
   public void testStop_stopsDbPoll_ifCacheIsEnabled()
   {
-    setupTargetWithCaching(true);
+    setupTargetWithCaching(SegmentMetadataCache.UsageMode.ALWAYS);
     Assert.assertTrue(cache.isEnabled());
 
     cache.start();
@@ -180,7 +179,7 @@ public void testStop_stopsDbPoll_ifCacheIsEnabled()
   @Test
   public void testBecomeLeader_isNoop_ifCacheIsDisabled()
   {
-    setupTargetWithCaching(false);
+    setupTargetWithCaching(SegmentMetadataCache.UsageMode.NEVER);
 
     cache.start();
     Assert.assertFalse(pollExecutor.hasPendingTasks());
@@ -192,7 +191,7 @@ public void testBecomeLeader_isNoop_ifCacheIsDisabled()
   @Test
   public void testBecomeLeader_throwsException_ifCacheIsStopped()
   {
-    setupTargetWithCaching(true);
+    setupTargetWithCaching(SegmentMetadataCache.UsageMode.ALWAYS);
     DruidExceptionMatcher.defensive().expectMessageIs(
         "Cache has not been started yet"
     ).assertThrowsAndMatches(
@@ -203,7 +202,7 @@ public void testBecomeLeader_throwsException_ifCacheIsStopped()
   @Test
   public void testGetDataSource_throwsException_ifCacheIsDisabled()
   {
-    setupTargetWithCaching(false);
+    setupTargetWithCaching(SegmentMetadataCache.UsageMode.NEVER);
     DruidExceptionMatcher.defensive().expectMessageIs(
         "Segment metadata cache is not enabled."
     ).assertThrowsAndMatches(
@@ -214,7 +213,7 @@ public void testGetDataSource_throwsException_ifCacheIsDisabled()
   @Test
   public void testGetDataSource_throwsException_ifCacheIsStoppedOrNotLeader()
   {
-    setupTargetWithCaching(true);
+    setupTargetWithCaching(SegmentMetadataCache.UsageMode.ALWAYS);
     Assert.assertTrue(cache.isEnabled());
 
     DruidExceptionMatcher.internalServerError().expectMessageIs(
@@ -234,7 +233,7 @@ public void testGetDataSource_throwsException_ifCacheIsStoppedOrNotLeader()
   @Test(timeout = 60_000)
   public void testGetDataSource_waitsForOneSync_afterBecomingLeader() throws InterruptedException
   {
-    setupTargetWithCaching(true);
+    setupTargetWithCaching(SegmentMetadataCache.UsageMode.ALWAYS);
     cache.start();
     cache.becomeLeader();
 
@@ -338,7 +337,7 @@ public void testSync_emitsAlert_ifErrorOccurs()
     );
 
     // Verify that sync duration is not emitted again
-    serviceEmitter.verifyEmitted(Metric.SYNC_DURATION_MILLIS, 1);
+    serviceEmitter.verifyNotEmitted(Metric.SYNC_DURATION_MILLIS);
   }
 
   @Test
@@ -361,7 +360,7 @@ public void testSync_doesNotFail_ifSegmentRecordIsBad()
     // Verify that sync completes successfully and updates the valid segment
     setupAndSyncCache();
     serviceEmitter.verifyEmitted(Metric.SYNC_DURATION_MILLIS, 1);
-    serviceEmitter.verifyValue(Metric.UPDATED_USED_SEGMENTS, 1L);
+    serviceEmitter.verifyValue(Metric.CACHED_USED_SEGMENTS, 1L);
     serviceEmitter.verifyValue(Metric.SKIPPED_SEGMENTS, 1L);
 
     final DatasourceSegmentCache wikiCache = cache.getDatasource(TestDataSource.WIKI);
@@ -409,7 +408,7 @@ public void testSync_doesNotFail_ifPendingSegmentRecordIsBad()
     setupAndSyncCache();
     serviceEmitter.verifyEmitted(Metric.SYNC_DURATION_MILLIS, 1);
     serviceEmitter.verifyValue(Metric.SKIPPED_PENDING_SEGMENTS, 1L);
-    serviceEmitter.verifyValue(Metric.UPDATED_USED_SEGMENTS, 1L);
+    serviceEmitter.verifyValue(Metric.CACHED_USED_SEGMENTS, 1L);
     serviceEmitter.verifyValue(Metric.PERSISTED_USED_SEGMENTS, 1L);
     serviceEmitter.verifyValue(Metric.PERSISTED_PENDING_SEGMENTS, 0L);
 
@@ -598,19 +597,6 @@ public void testSync_removesPendingSegment_ifNotPresentInMetadataStore()
     );
   }
 
-  @Test
-  public void testGetDatasource_increasesTransactionCount()
-  {
-    setupAndSyncCache();
-    cache.getDatasource(TestDataSource.WIKI);
-    cache.getDatasource(TestDataSource.WIKI);
-    serviceEmitter.verifyEmitted(
-        Metric.TRANSACTION_COUNT,
-        Map.of(DruidMetrics.DATASOURCE, TestDataSource.WIKI),
-        2
-    );
-  }
-
   private void insertSegmentsInMetadataStore(Set<DataSegmentPlus> segments)
   {
     final String table = derbyConnectorRule.metadataTablesConfigSupplier().get().getSegmentsTable();
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/duty/KillUnusedSegmentsTest.java b/server/src/test/java/org/apache/druid/server/coordinator/duty/KillUnusedSegmentsTest.java
index 272ed1887ce7..1f02a5e9db97 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/duty/KillUnusedSegmentsTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/duty/KillUnusedSegmentsTest.java
@@ -111,7 +111,7 @@ public class KillUnusedSegmentsTest
   public void setup()
   {
     connector = derbyConnectorRule.getConnector();
-    SegmentsMetadataManagerConfig config = new SegmentsMetadataManagerConfig(Period.millis(1), false);
+    SegmentsMetadataManagerConfig config = new SegmentsMetadataManagerConfig(Period.millis(1), null);
     sqlSegmentsMetadataManager = new SqlSegmentsMetadataManager(
         TestHelper.makeJsonMapper(),
         Suppliers.ofInstance(config),

From 21b1ee0045c1b2caba9ce601136f1fca0445f9dd Mon Sep 17 00:00:00 2001
From: Andy Tsai <61856143+weishiuntsai@users.noreply.github.com>
Date: Thu, 27 Mar 2025 21:05:25 -0700
Subject: [PATCH 63/99] Add json, array, aggregation function tests to quidem
 (#17842)

This PR adds the sql-native portion of the json, array, and aggregation function tests to quidem.  It adds a total of 9965 queries, with 6752 positive tests and 3213 negative tests.
---
 .../qaAggFuncs_array_agg_double.iq            |  2241 +
 .../qaAggFuncs_array_agg_float.iq             |  2241 +
 .../qaAggFuncs_array_agg_long.iq              |  2117 +
 .../qaAggFuncs_array_agg_misc.iq              |   323 +
 .../qaAggFuncs_array_agg_string.iq            |  2235 +
 .../qaAggFuncs_array_agg_timestamp.iq         |  1750 +
 .../qaAggFuncs_string_agg_double.iq           |  4597 ++
 .../qaAggFuncs_string_agg_float.iq            |  4597 ++
 .../qaAggFuncs_string_agg_long.iq             |  3753 +
 .../qaAggFuncs_string_agg_misc.iq             |   859 +
 .../qaAggFuncs_string_agg_string.iq           |  3753 +
 .../qaAggFuncs_string_agg_timestamp.iq        |  3675 +
 .../qaArray_ops_funcs.iq                      | 39328 ++++++++++
 .../qaArray_sql.iq                            | 62751 ++++++++++++++++
 .../qaJsonCols_funcs_and_sql.iq               | 15280 ++++
 .../quidem/qatests/qaAggFuncs/ingest.json     |    66 +
 .../qatests/qaArray/ops_funcs/ingest.json     |   219 +
 .../quidem/qatests/qaArray/sql/ingest.json    |   219 +
 .../qaJsonCols/funcs_and_sql/ingest.json      |   242 +
 19 files changed, 150246 insertions(+)
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_double.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_float.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_long.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_misc.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_string.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_timestamp.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_double.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_float.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_long.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_misc.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_string.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_timestamp.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaArray_ops_funcs.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaArray_sql.iq
 create mode 100644 quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaJsonCols_funcs_and_sql.iq
 create mode 100644 sql/src/test/quidem/qatests/qaAggFuncs/ingest.json
 create mode 100644 sql/src/test/quidem/qatests/qaArray/ops_funcs/ingest.json
 create mode 100644 sql/src/test/quidem/qatests/qaArray/sql/ingest.json
 create mode 100644 sql/src/test/quidem/qatests/qaJsonCols/funcs_and_sql/ingest.json

diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_double.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_double.iq
new file mode 100644
index 000000000000..7b8ec969d231
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_double.iq
@@ -0,0 +1,2241 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaAggFuncs&numMergeBuffers=3
+!set outputformat mysql
+SELECT count(*) cnt
+FROM test_agg_funcs;
++-----+
+| cnt |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(111.1111111) AS col)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(tab0d0) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(tab0d0)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(tab0d0), 100) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(tab0d0), 100) AS col
+FROM test_agg_funcs
+WHERE tab0d0>222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_contains(array_agg(tab0d0), 111.1111111) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_contains(array_agg(tab0d0), array[111.1111111, 222.2222222]) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0d0), 333.3333333) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0d0), array[111.1111111, 333.3333333]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_overlap(array_agg(tab0d0), array[111.1111111, 333.3333333]) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(tab0d0), array[333.3333333, 444.4444444]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_overlap(array_agg(tab0d0), array_agg(DISTINCT tab0d0)) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_offset_of(array_agg(tab0d0), 111.1111111) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(tab0d0), 333.3333333) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_ordinal_of(array_agg(tab0d0), 111.1111111) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(tab0d0), 333.3333333) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(tab0d0), '|') AS col
+   FROM test_agg_funcs)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(tab0d0), '|'), '111.')
+AND contains_string(array_to_string(array_agg(DISTINCT tab0d0), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_prepend(333.3333333, array_agg(tab0d0)) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_prepend(333.3333333, array_agg(tab0d0))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_append(array_agg(tab0d0), 333.3333333) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_append(array_agg(tab0d0), 333.3333333)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(tab0d0), array[333.3333333])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_concat(array_agg(tab0d0), array_agg(tab0d0)) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(tab0d0), array_agg(tab0d0))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  36 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_slice(array_agg(tab0d0), 0, 1) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_slice(array_agg(tab0d0), 100, 101) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A28 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(t0.tab0d0) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0d0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A29 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(array_agg(t0.tab0d0), '') AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0d0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A30 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(t0.tab0d0), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0d0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A31 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(t0.tab0d0) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0d0;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A32 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(array_agg(t0.tab0d0), '') AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0d0;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A33 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(t0.tab0d0), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0d0;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(DISTINCT 111.1111111) AS col)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(DISTINCT tab0d0) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(DISTINCT tab0d0)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(DISTINCT tab0d0), 100) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(DISTINCT tab0d0), 100) AS col
+FROM test_agg_funcs
+WHERE tab0d0>222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_contains(array_agg(DISTINCT tab0d0), 111.1111111) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_contains(array_agg(DISTINCT tab0d0), array[111.1111111, 222.2222222]) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0d0), 333.3333333) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0d0), array[111.1111111, 333.3333333]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_overlap(array_agg(DISTINCT tab0d0), array[111.1111111, 333.3333333]) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT tab0d0), array[333.3333333, 444.4444444]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_overlap(array_agg(DISTINCT tab0d0), array_agg(DISTINCT tab0d0)) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_offset_of(array_agg(DISTINCT tab0d0), 111.1111111) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(DISTINCT tab0d0), 333.3333333) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_ordinal_of(array_agg(DISTINCT tab0d0), 111.1111111) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(DISTINCT tab0d0), 333.3333333) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT tab0d0), '|') AS col
+   FROM test_agg_funcs)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(DISTINCT tab0d0), '|'), '111.')
+AND contains_string(array_to_string(array_agg(DISTINCT tab0d0), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_prepend(333.3333333, array_agg(DISTINCT tab0d0)) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_prepend(333.3333333, array_agg(DISTINCT tab0d0))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_append(array_agg(DISTINCT tab0d0), 333.3333333) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_append(array_agg(DISTINCT tab0d0), 333.3333333)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT tab0d0), array[333.3333333])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_concat(array_agg(DISTINCT tab0d0), array_agg(DISTINCT tab0d0)) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT tab0d0), array_agg(DISTINCT tab0d0))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   6 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_slice(array_agg(DISTINCT tab0d0), 0, 1) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(DISTINCT tab0d0), 100, 101) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(DISTINCT t0.tab0d0) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0d0 IS NOT NULL)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.tab0d0), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0d0 IS NOT NULL)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(array_to_string(array_agg(DISTINCT t0.tab0d0), '')) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0d0 IS NOT NULL)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(DISTINCT t0.tab0d0) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0d0)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.tab0d0), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0d0)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(array_to_string(array_agg(DISTINCT t0.tab0d0), '')) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0d0)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(111.1111111, 100000) AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(DISTINCT tab0d0, 100000) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(DISTINCT tab0d0, 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(DISTINCT tab0d0, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(DISTINCT tab0d0, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE tab0d0>222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_contains(array_agg(DISTINCT tab0d0, 100000), 111.1111111) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_contains(array_agg(DISTINCT tab0d0, 100000), array[111.1111111, 222.2222222]) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0d0, 100000), 333.3333333) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0d0, 100000), array[111.1111111, 333.3333333]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_overlap(array_agg(DISTINCT tab0d0, 100000), array[111.1111111, 333.3333333]) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT tab0d0, 100000), array[333.3333333, 444.4444444]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_overlap(array_agg(DISTINCT tab0d0, 100000), array_agg(DISTINCT tab0d0, 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_offset_of(array_agg(DISTINCT tab0d0, 100000), 111.1111111) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(DISTINCT tab0d0, 100000), 333.3333333) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_ordinal_of(array_agg(DISTINCT tab0d0, 100000), 111.1111111) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(DISTINCT tab0d0, 100000), 333.3333333) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT tab0d0, 100000), '|') AS col
+   FROM test_agg_funcs)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(DISTINCT tab0d0, 100000), '|'), '111.')
+AND contains_string(array_to_string(array_agg(DISTINCT tab0d0, 100000), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_prepend(333.3333333, array_agg(DISTINCT tab0d0, 100000)) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_prepend(333.3333333, array_agg(DISTINCT tab0d0, 100000))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_append(array_agg(DISTINCT tab0d0, 100000), 333.3333333) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_append(array_agg(DISTINCT tab0d0, 100000), 333.3333333)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT tab0d0, 100000), array[333.3333333])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_concat(array_agg(DISTINCT tab0d0, 100000), array_agg(DISTINCT tab0d0, 100000)) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT tab0d0, 100000), array_agg(DISTINCT tab0d0, 100000))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   6 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_slice(array_agg(DISTINCT tab0d0, 100000), 0, 1) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(DISTINCT tab0d0, 100000), 100, 101) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(DISTINCT t0.tab0d0, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0d0 IS NOT NULL)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.tab0d0, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0d0 IS NOT NULL)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(array_to_string(array_agg(DISTINCT t0.tab0d0, 100000), '')) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0d0 IS NOT NULL)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(DISTINCT t0.tab0d0, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0d0)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.tab0d0, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0d0)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(array_to_string(array_agg(DISTINCT t0.tab0d0, 100000), '')) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0d0)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(111.1111111, 100000);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(tab0d0, 100000) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(tab0d0, 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(tab0d0, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(tab0d0, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE tab0d0>222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_contains(array_agg(tab0d0, 100000), 111.1111111) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_contains(array_agg(tab0d0, 100000), array[111.1111111, 222.2222222]) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0d0, 100000), 333.3333333) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0d0, 100000), array[111.1111111, 333.3333333]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_overlap(array_agg(tab0d0, 100000), array[111.1111111, 333.3333333]) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(tab0d0, 100000), array[333.3333333, 444.4444444]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_overlap(array_agg(tab0d0, 100000), array_agg(tab0d0, 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_offset_of(array_agg(tab0d0, 100000), 111.1111111) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(tab0d0, 100000), 333.3333333) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_ordinal_of(array_agg(tab0d0, 100000), 111.1111111) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(tab0d0, 100000), 333.3333333) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(tab0d0, 100000), '|') AS col
+   FROM test_agg_funcs)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(tab0d0, 100000), '|'), '111.')
+AND contains_string(array_to_string(array_agg(tab0d0, 100000), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_prepend(333.3333333, array_agg(tab0d0, 100000)) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_prepend(333.3333333, array_agg(tab0d0, 100000))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_append(array_agg(tab0d0, 100000), 333.3333333) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_append(array_agg(tab0d0, 100000), 333.3333333)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(tab0d0, 100000), array[333.3333333])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_concat(array_agg(tab0d0, 100000), array_agg(tab0d0, 100000)) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(tab0d0, 100000), array_agg(tab0d0, 100000))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  36 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_slice(array_agg(tab0d0, 100000), 0, 1) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(tab0d0, 100000), 100, 101) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(t0.tab0d0, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0d0 IS NOT NULL)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(t0.tab0d0, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0d0 IS NOT NULL)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(array_to_string(array_agg(t0.tab0d0, 100000), '')) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0d0 IS NOT NULL)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(t0.tab0d0, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0d0)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(t0.tab0d0, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0d0)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(array_to_string(array_agg(t0.tab0d0, 100000), '')) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0d0)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 133 Positive tests: 125 Negative tests: 8
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_float.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_float.iq
new file mode 100644
index 000000000000..04f57110960a
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_float.iq
@@ -0,0 +1,2241 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaAggFuncs&numMergeBuffers=3
+!set outputformat mysql
+SELECT count(*) cnt
+FROM test_agg_funcs;
++-----+
+| cnt |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(11.1111111) AS col)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(tab0f0) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(tab0f0)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(tab0f0), 100) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(tab0f0), 100) AS col
+FROM test_agg_funcs
+WHERE tab0f0>222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_contains(array_agg(tab0f0), 11.1111111) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_contains(array_agg(tab0f0), array[11.1111111, 22.2222222]) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0f0), 33.3333333) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0f0), array[11.1111111, 33.3333333]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_overlap(array_agg(tab0f0), array[11.1111111, 33.3333333]) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(tab0f0), array[33.3333333, 44.4444444]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_overlap(array_agg(tab0f0), array_agg(DISTINCT tab0f0)) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_offset_of(array_agg(tab0f0), 11.1111111) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(tab0f0), 33.3333333) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_ordinal_of(array_agg(tab0f0), 11.1111111) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(tab0f0), 33.3333333) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(tab0f0), '|') AS col
+   FROM test_agg_funcs)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(tab0f0), '|'), '11.')
+AND contains_string(array_to_string(array_agg(DISTINCT tab0f0), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_prepend(33.3333333, array_agg(tab0f0)) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_prepend(33.3333333, array_agg(tab0f0))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_append(array_agg(tab0f0), 33.3333333) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_append(array_agg(tab0f0), 33.3333333)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(tab0f0), array[33.3333333])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_concat(array_agg(tab0f0), array_agg(tab0f0)) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(tab0f0), array_agg(tab0f0))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  36 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_slice(array_agg(tab0f0), 0, 1) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_slice(array_agg(tab0f0), 100, 101) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A28 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(t0.tab0f0) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0f0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A29 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(array_agg(t0.tab0f0), '') AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0f0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A30 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(t0.tab0f0), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0f0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A31 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(t0.tab0f0) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0f0;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A32 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(array_agg(t0.tab0f0), '') AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0f0;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A33 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(t0.tab0f0), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0f0;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(DISTINCT 11.1111111) AS col)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(DISTINCT tab0f0) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(DISTINCT tab0f0)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(DISTINCT tab0f0), 100) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(DISTINCT tab0f0), 100) AS col
+FROM test_agg_funcs
+WHERE tab0f0>222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_contains(array_agg(DISTINCT tab0f0), 11.1111111) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_contains(array_agg(DISTINCT tab0f0), array[11.1111111, 22.2222222]) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0f0), 33.3333333) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0f0), array[11.1111111, 33.3333333]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_overlap(array_agg(DISTINCT tab0f0), array[11.1111111, 33.3333333]) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT tab0f0), array[33.3333333, 44.4444444]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_overlap(array_agg(DISTINCT tab0f0), array_agg(DISTINCT tab0f0)) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_offset_of(array_agg(DISTINCT tab0f0), 11.1111111) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(DISTINCT tab0f0), 33.3333333) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_ordinal_of(array_agg(DISTINCT tab0f0), 11.1111111) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(DISTINCT tab0f0), 33.3333333) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT tab0f0), '|') AS col
+   FROM test_agg_funcs)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(DISTINCT tab0f0), '|'), '11.')
+AND contains_string(array_to_string(array_agg(DISTINCT tab0f0), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_prepend(33.3333333, array_agg(DISTINCT tab0f0)) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_prepend(33.3333333, array_agg(DISTINCT tab0f0))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_append(array_agg(DISTINCT tab0f0), 33.3333333) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_append(array_agg(DISTINCT tab0f0), 33.3333333)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT tab0f0), array[33.3333333])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_concat(array_agg(DISTINCT tab0f0), array_agg(DISTINCT tab0f0)) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT tab0f0), array_agg(DISTINCT tab0f0))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   6 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_slice(array_agg(DISTINCT tab0f0), 0, 1) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(DISTINCT tab0f0), 100, 101) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(DISTINCT t0.tab0f0) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0f0 IS NOT NULL)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.tab0f0), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0f0 IS NOT NULL)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(array_to_string(array_agg(DISTINCT t0.tab0f0), '')) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0f0 IS NOT NULL)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(DISTINCT t0.tab0f0) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0f0)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.tab0f0), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0f0)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(array_to_string(array_agg(DISTINCT t0.tab0f0), '')) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0f0)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(11.1111111, 100000) AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(DISTINCT tab0f0, 100000) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(DISTINCT tab0f0, 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(DISTINCT tab0f0, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(DISTINCT tab0f0, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE tab0f0>222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_contains(array_agg(DISTINCT tab0f0, 100000), 11.1111111) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_contains(array_agg(DISTINCT tab0f0, 100000), array[11.1111111, 22.2222222]) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0f0, 100000), 33.3333333) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0f0, 100000), array[11.1111111, 33.3333333]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_overlap(array_agg(DISTINCT tab0f0, 100000), array[11.1111111, 33.3333333]) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT tab0f0, 100000), array[33.3333333, 44.4444444]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_overlap(array_agg(DISTINCT tab0f0, 100000), array_agg(DISTINCT tab0f0, 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_offset_of(array_agg(DISTINCT tab0f0, 100000), 11.1111111) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(DISTINCT tab0f0, 100000), 33.3333333) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_ordinal_of(array_agg(DISTINCT tab0f0, 100000), 11.1111111) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(DISTINCT tab0f0, 100000), 33.3333333) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT tab0f0, 100000), '|') AS col
+   FROM test_agg_funcs)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(DISTINCT tab0f0, 100000), '|'), '11.')
+AND contains_string(array_to_string(array_agg(DISTINCT tab0f0, 100000), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_prepend(33.3333333, array_agg(DISTINCT tab0f0, 100000)) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_prepend(33.3333333, array_agg(DISTINCT tab0f0, 100000))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_append(array_agg(DISTINCT tab0f0, 100000), 33.3333333) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_append(array_agg(DISTINCT tab0f0, 100000), 33.3333333)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT tab0f0, 100000), array[33.3333333])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_concat(array_agg(DISTINCT tab0f0, 100000), array_agg(DISTINCT tab0f0, 100000)) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT tab0f0, 100000), array_agg(DISTINCT tab0f0, 100000))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   6 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_slice(array_agg(DISTINCT tab0f0, 100000), 0, 1) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(DISTINCT tab0f0, 100000), 100, 101) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(DISTINCT t0.tab0f0, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0f0 IS NOT NULL)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.tab0f0, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0f0 IS NOT NULL)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(array_to_string(array_agg(DISTINCT t0.tab0f0, 100000), '')) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0f0 IS NOT NULL)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(DISTINCT t0.tab0f0, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0f0)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.tab0f0, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0f0)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(array_to_string(array_agg(DISTINCT t0.tab0f0, 100000), '')) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0f0)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(11.1111111, 100000);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(tab0f0, 100000) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(tab0f0, 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(tab0f0, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(tab0f0, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE tab0f0>222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_contains(array_agg(tab0f0, 100000), 11.1111111) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_contains(array_agg(tab0f0, 100000), array[11.1111111, 22.2222222]) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0f0, 100000), 33.3333333) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0f0, 100000), array[11.1111111, 33.3333333]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_overlap(array_agg(tab0f0, 100000), array[11.1111111, 33.3333333]) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(tab0f0, 100000), array[33.3333333, 44.4444444]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_overlap(array_agg(tab0f0, 100000), array_agg(tab0f0, 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col IS TRUE
+  OR col IS FALSE
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_offset_of(array_agg(tab0f0, 100000), 11.1111111) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(tab0f0, 100000), 33.3333333) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_ordinal_of(array_agg(tab0f0, 100000), 11.1111111) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(tab0f0, 100000), 33.3333333) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(tab0f0, 100000), '|') AS col
+   FROM test_agg_funcs)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(tab0f0, 100000), '|'), '11.')
+AND contains_string(array_to_string(array_agg(tab0f0, 100000), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_prepend(33.3333333, array_agg(tab0f0, 100000)) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_prepend(33.3333333, array_agg(tab0f0, 100000))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_append(array_agg(tab0f0, 100000), 33.3333333) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_append(array_agg(tab0f0, 100000), 33.3333333)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(tab0f0, 100000), array[33.3333333])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_concat(array_agg(tab0f0, 100000), array_agg(tab0f0, 100000)) AS col
+   FROM test_agg_funcs)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(tab0f0, 100000), array_agg(tab0f0, 100000))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  36 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_slice(array_agg(tab0f0, 100000), 0, 1) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(tab0f0, 100000), 100, 101) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(t0.tab0f0, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0f0 IS NOT NULL)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(t0.tab0f0, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0f0 IS NOT NULL)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(array_to_string(array_agg(t0.tab0f0, 100000), '')) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0f0 IS NOT NULL)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(t0.tab0f0, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0f0)
+WHERE NOT array_contains(col, 99999)
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_to_string(array_agg(t0.tab0f0, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0f0)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(array_to_string(array_agg(t0.tab0f0, 100000), '')) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0f0)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 133 Positive tests: 125 Negative tests: 8
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_long.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_long.iq
new file mode 100644
index 000000000000..032ed7fe551f
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_long.iq
@@ -0,0 +1,2117 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaAggFuncs&numMergeBuffers=3
+!set outputformat mysql
+SELECT count(*) cnt
+FROM test_agg_funcs;
++-----+
+| cnt |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[1111111111,
+             2222222222] AS col;
++--------------------------+
+| col                      |
++--------------------------+
+| [1111111111, 2222222222] |
++--------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(1111111111) AS col;
++--------------+
+| col          |
++--------------+
+| [1111111111] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(tab0l0) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 161 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(tab0l0)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(tab0l0), 100) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(tab0l0), 100) AS col
+FROM test_agg_funcs
+WHERE tab0l0=2222222222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0l0), 1111111111) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0l0), array[1111111111, 2222222222]) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0l0), 3333333333) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0l0), array[1111111111, 3333333333]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(tab0l0), array[1111111111, 3333333333]) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(tab0l0), array[3333333333, 4444444444]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(tab0l0), array_agg(DISTINCT tab0l0)) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(tab0l0), 1111111111) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(tab0l0), 3333333333) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(tab0l0), 1111111111) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(tab0l0), 3333333333) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(array_agg(tab0l0), '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 161 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(tab0l0), '|'), '1111111111')
+AND contains_string(array_to_string(array_agg(DISTINCT tab0l0), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_prepend(3333333333, array_agg(tab0l0)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 172 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_prepend(3333333333, array_agg(tab0l0))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_append(array_agg(tab0l0), 3333333333) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 172 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_append(array_agg(tab0l0), 3333333333)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(tab0l0), array[3333333333]) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 172 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(tab0l0), array[3333333333])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(tab0l0), array_agg(tab0l0)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 323 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(tab0l0), array_agg(tab0l0))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  36 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(tab0l0), 0, 1) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++--------------+
+| col          |
++--------------+
+| [1111111111] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(tab0l0), 100, 101) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A30 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(t0.tab0l0) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0l0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A31 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(array_agg(t0.tab0l0), '') AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0l0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A32 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(t0.tab0l0), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0l0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A33 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(t0.tab0l0) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0l0;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A34 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(array_agg(t0.tab0l0), '') AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0l0;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A35 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(t0.tab0l0), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0l0;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[1111111111,
+             2222222222] AS col;
++--------------------------+
+| col                      |
++--------------------------+
+| [1111111111, 2222222222] |
++--------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT 1111111111) AS col;
++--------------+
+| col          |
++--------------+
+| [1111111111] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(DISTINCT tab0l0) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  26 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(DISTINCT tab0l0)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(DISTINCT tab0l0), 100) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(DISTINCT tab0l0), 100) AS col
+FROM test_agg_funcs
+WHERE tab0l0=2222222222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0l0), 1111111111) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0l0), array[1111111111, 2222222222]) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0l0), 3333333333) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0l0), array[1111111111, 3333333333]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT tab0l0), array[1111111111, 3333333333]) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT tab0l0), array[3333333333, 4444444444]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT tab0l0), array_agg(DISTINCT tab0l0)) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(DISTINCT tab0l0), 1111111111) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(DISTINCT tab0l0), 3333333333) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(DISTINCT tab0l0), 1111111111) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(DISTINCT tab0l0), 3333333333) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(array_agg(DISTINCT tab0l0), '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  26 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(DISTINCT tab0l0), '|'), '1111111111')
+AND contains_string(array_to_string(array_agg(DISTINCT tab0l0), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_prepend(3333333333, array_agg(DISTINCT tab0l0)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  37 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_prepend(3333333333, array_agg(DISTINCT tab0l0))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_append(array_agg(DISTINCT tab0l0), 3333333333) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  37 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_append(array_agg(DISTINCT tab0l0), 3333333333)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(DISTINCT tab0l0), array[3333333333]) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  37 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT tab0l0), array[3333333333])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(DISTINCT tab0l0), array_agg(DISTINCT tab0l0)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  53 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT tab0l0), array_agg(DISTINCT tab0l0))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   6 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(DISTINCT tab0l0), 0, 1) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++--------------+
+| col          |
++--------------+
+| [1111111111] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(DISTINCT tab0l0), 100, 101) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(DISTINCT t0.tab0l0) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0l0 IS NOT NULL);
++-----+
+| LEN |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) AS LEN
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.tab0l0), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0l0 IS NOT NULL);
++-----+
+| LEN |
++-----+
+|  20 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(DISTINCT t0.tab0l0), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0l0 IS NOT NULL;
++-----+
+| col |
++-----+
+|  20 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(DISTINCT t0.tab0l0) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0l0);
++-----+
+| LEN |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) AS LEN
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.tab0l0), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0l0);
++-----+
+| LEN |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(DISTINCT t0.tab0l0), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0l0;
++-----+
+| col |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[1111111111,
+             2222222222] AS col;
++--------------------------+
+| col                      |
++--------------------------+
+| [1111111111, 2222222222] |
++--------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A02 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT 1111111111, 100000) AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(DISTINCT tab0l0, 100000) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  26 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(DISTINCT tab0l0, 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(DISTINCT tab0l0, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(DISTINCT tab0l0, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE tab0l0=2222222222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0l0, 100000), 1111111111) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0l0, 100000), array[1111111111, 2222222222]) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0l0, 100000), 3333333333) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0l0, 100000), array[1111111111, 3333333333]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT tab0l0, 100000), array[1111111111, 3333333333]) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT tab0l0, 100000), array[3333333333, 4444444444]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT tab0l0, 100000), array_agg(DISTINCT tab0l0, 100000)) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(DISTINCT tab0l0, 100000), 1111111111) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(DISTINCT tab0l0, 100000), 3333333333) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(DISTINCT tab0l0, 100000), 1111111111) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(DISTINCT tab0l0, 100000), 3333333333) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(array_agg(DISTINCT tab0l0, 100000), '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  26 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(DISTINCT tab0l0, 100000), '|'), '1111111111')
+AND contains_string(array_to_string(array_agg(DISTINCT tab0l0, 100000), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_prepend(3333333333, array_agg(DISTINCT tab0l0, 100000)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  37 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_prepend(3333333333, array_agg(DISTINCT tab0l0, 100000))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_append(array_agg(DISTINCT tab0l0, 100000), 3333333333) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  37 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_append(array_agg(DISTINCT tab0l0, 100000), 3333333333)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(DISTINCT tab0l0, 100000), array[3333333333]) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  37 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT tab0l0, 100000), array[3333333333])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(DISTINCT tab0l0, 100000), array_agg(DISTINCT tab0l0, 100000)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  53 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT tab0l0, 100000), array_agg(DISTINCT tab0l0, 100000))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   6 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(DISTINCT tab0l0, 100000), 0, 1) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++--------------+
+| col          |
++--------------+
+| [1111111111] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(DISTINCT tab0l0, 100000), 100, 101) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(DISTINCT t0.tab0l0, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0l0 IS NOT NULL);
++-----+
+| LEN |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) AS LEN
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.tab0l0, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0l0 IS NOT NULL);
++-----+
+| LEN |
++-----+
+|  20 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(DISTINCT t0.tab0l0, 100000), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0l0 IS NOT NULL;
++-----+
+| col |
++-----+
+|  20 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(DISTINCT t0.tab0l0, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0l0);
++-----+
+| LEN |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) AS LEN
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.tab0l0, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0l0);
++-----+
+| LEN |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(DISTINCT t0.tab0l0, 100000), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0l0;
++-----+
+| col |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[1111111111,
+             2222222222] AS col;
++--------------------------+
+| col                      |
++--------------------------+
+| [1111111111, 2222222222] |
++--------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A02 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(1111111111, 100000) AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(tab0l0, 100000) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 161 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(tab0l0, 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(tab0l0, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(tab0l0, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE tab0l0=2222222222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0l0, 100000), 1111111111) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0l0, 100000), array[1111111111, 2222222222]) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0l0, 100000), 3333333333) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0l0, 100000), array[1111111111, 3333333333]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(tab0l0, 100000), array[1111111111, 3333333333]) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(tab0l0, 100000), array[3333333333, 4444444444]) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(tab0l0, 100000), array_agg(tab0l0, 100000)) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(tab0l0, 100000), 1111111111) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(tab0l0, 100000), 3333333333) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(tab0l0, 100000), 1111111111) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(tab0l0, 100000), 3333333333) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_to_string(array_agg(tab0l0, 100000), '|') AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 161 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(tab0l0, 100000), '|'), '1111111111')
+AND contains_string(array_to_string(array_agg(tab0l0, 100000), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_prepend(3333333333, array_agg(tab0l0, 100000)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 172 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_prepend(3333333333, array_agg(tab0l0, 100000))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_append(array_agg(tab0l0, 100000), 3333333333) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 172 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_append(array_agg(tab0l0, 100000), 3333333333)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(tab0l0, 100000), array[3333333333]) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 172 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(tab0l0, 100000), array[3333333333])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(tab0l0, 100000), array_agg(tab0l0, 100000)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 323 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(tab0l0, 100000), array_agg(tab0l0, 100000))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  36 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(tab0l0, 100000), 0, 1) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++--------------+
+| col          |
++--------------+
+| [1111111111] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(tab0l0, 100000), 100, 101) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(t0.tab0l0, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0l0 IS NOT NULL);
++-------+
+| LEN   |
++-------+
+| 42767 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) AS LEN
+FROM
+  (SELECT array_to_string(array_agg(t0.tab0l0, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0l0 IS NOT NULL);
++-------+
+| LEN   |
++-------+
+| 38880 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(t0.tab0l0, 100000), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0l0 IS NOT NULL;
++-------+
+| col   |
++-------+
+| 38880 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(t0.tab0l0, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0l0);
++-------+
+| LEN   |
++-------+
+| 21383 |
+| 21383 |
+|  9719 |
++-------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) AS LEN
+FROM
+  (SELECT array_to_string(array_agg(t0.tab0l0, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0l0);
++-------+
+| LEN   |
++-------+
+| 19440 |
+| 19440 |
+|  7776 |
++-------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(t0.tab0l0, 100000), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0l0;
++-------+
+| col   |
++-------+
+| 19440 |
+| 19440 |
+|  7776 |
++-------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 141 Positive tests: 133 Negative tests: 8
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_misc.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_misc.iq
new file mode 100644
index 000000000000..14cc7ffe816c
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_misc.iq
@@ -0,0 +1,323 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaAggFuncs&numMergeBuffers=3
+!set outputformat mysql
+SELECT count(*) cnt
+FROM test_agg_funcs;
++-----+
+| cnt |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(tab0s0) AS c1,
+          array_agg(tab0l0) AS c2,
+          array_agg(tab0d0) AS c3,
+          array_agg(tab0f0) AS c4,
+          array_agg(__time) AS c5
+   FROM test_agg_funcs)
+WHERE (NOT array_contains(c1, '99999')
+       OR c1 IS NULL)
+  AND (NOT array_contains(c2, 99999)
+       OR c2 IS NULL)
+  AND (NOT array_contains(c3, 99999)
+       OR c3 IS NULL)
+  AND (NOT array_contains(c4, 99999)
+       OR c4 IS NULL)
+  AND (NOT array_contains(c5, ARRAY[timestamp '1970-01-01 01:01:01'])
+       OR c5 IS NULL);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A02 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(tab0s0) c1,
+       tab0l0,
+       tab0d0
+FROM test_agg_funcs;
+is not being grouped
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT array_agg(tab0s0) AS c1,
+          tab0l0 AS c2,
+          tab0d0 AS c3
+   FROM test_agg_funcs
+   GROUP BY tab0s0,
+            tab0l0,
+            tab0d0)
+WHERE (NOT array_contains(c1, '99999')
+       OR c1 IS NULL);
++-----+
+| cnt |
++-----+
+|   9 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(tab0s0||'1', 100000)) AS c1,
+       array_length(array_agg(tab0s0||'2', 100000)) AS c2,
+       array_length(array_agg(tab0s0||'3', 100000)) AS c3,
+       array_length(array_agg(tab0s0||'4', 100000)) AS c4,
+       array_length(array_agg(tab0s0||'5', 100000)) AS c5,
+       array_length(array_agg(tab0s0||'6', 100000)) AS c6,
+       array_length(array_agg(tab0s0||'7', 100000)) AS c7,
+       array_length(array_agg(tab0s0||'8', 100000)) AS c8,
+       array_length(array_agg(tab0s0||'9', 100000)) AS c9,
+       array_length(array_agg(tab0s0||'10', 100000)) AS c10,
+       array_length(array_agg(tab0s0||'11', 100000)) AS c11,
+       array_length(array_agg(tab0s0||'12', 100000)) AS c12,
+       array_length(array_agg(tab0s0||'13', 100000)) AS c13,
+       array_length(array_agg(tab0s0||'14', 100000)) AS c14,
+       array_length(array_agg(tab0s0||'15', 100000)) AS c15,
+       array_length(array_agg(tab0s0||'16', 100000)) AS c16,
+       array_length(array_agg(tab0s0||'17', 100000)) AS c17,
+       array_length(array_agg(tab0s0||'18', 100000)) AS c18,
+       array_length(array_agg(tab0s0||'19', 100000)) AS c19,
+       array_length(array_agg(tab0s0||'20', 100000)) AS c20,
+       array_length(array_agg(tab0s0||'21', 100000)) AS c21,
+       array_length(array_agg(tab0s0||'22', 100000)) AS c22,
+       array_length(array_agg(tab0s0||'23', 100000)) AS c23,
+       array_length(array_agg(tab0s0||'24', 100000)) AS c24,
+       array_length(array_agg(tab0s0||'25', 100000)) AS c25,
+       array_length(array_agg(tab0s0||'26', 100000)) AS c26,
+       array_length(array_agg(tab0s0||'27', 100000)) AS c27,
+       array_length(array_agg(tab0s0||'28', 100000)) AS c28,
+       array_length(array_agg(tab0s0||'29', 100000)) AS c29,
+       array_length(array_agg(tab0s0||'30', 100000)) AS c30,
+       array_length(array_agg(tab0s0||'31', 100000)) AS c31,
+       array_length(array_agg(tab0s0||'32', 100000)) AS c32,
+       array_length(array_agg(tab0s0||'33', 100000)) AS c33,
+       array_length(array_agg(tab0s0||'34', 100000)) AS c34,
+       array_length(array_agg(tab0s0||'35', 100000)) AS c35,
+       array_length(array_agg(tab0s0||'36', 100000)) AS c36,
+       array_length(array_agg(tab0s0||'37', 100000)) AS c37,
+       array_length(array_agg(tab0s0||'38', 100000)) AS c38,
+       array_length(array_agg(tab0s0||'39', 100000)) AS c39,
+       array_length(array_agg(tab0s0||'40', 100000)) AS c40,
+       array_length(array_agg(tab0s0||'41', 100000)) AS c41,
+       array_length(array_agg(tab0s0||'42', 100000)) AS c42,
+       array_length(array_agg(tab0s0||'43', 100000)) AS c43,
+       array_length(array_agg(tab0s0||'44', 100000)) AS c44,
+       array_length(array_agg(tab0s0||'45', 100000)) AS c45,
+       array_length(array_agg(tab0s0||'46', 100000)) AS c46,
+       array_length(array_agg(tab0s0||'47', 100000)) AS c47,
+       array_length(array_agg(tab0s0||'48', 100000)) AS c48,
+       array_length(array_agg(tab0s0||'49', 100000)) AS c49,
+       array_length(array_agg(tab0s0||'50', 100000)) AS c50,
+       array_length(array_agg(tab0s0||'51', 100000)) AS c51,
+       array_length(array_agg(tab0s0||'52', 100000)) AS c52,
+       array_length(array_agg(tab0s0||'53', 100000)) AS c53,
+       array_length(array_agg(tab0s0||'54', 100000)) AS c54,
+       array_length(array_agg(tab0s0||'55', 100000)) AS c55,
+       array_length(array_agg(tab0s0||'56', 100000)) AS c56,
+       array_length(array_agg(tab0s0||'57', 100000)) AS c57,
+       array_length(array_agg(tab0s0||'58', 100000)) AS c58,
+       array_length(array_agg(tab0s0||'59', 100000)) AS c59,
+       array_length(array_agg(tab0s0||'60', 100000)) AS c60,
+       array_length(array_agg(tab0s0||'61', 100000)) AS c61,
+       array_length(array_agg(tab0s0||'62', 100000)) AS c62,
+       array_length(array_agg(tab0s0||'63', 100000)) AS c63,
+       array_length(array_agg(tab0s0||'64', 100000)) AS c64,
+       array_length(array_agg(tab0s0||'65', 100000)) AS c65,
+       array_length(array_agg(tab0s0||'66', 100000)) AS c66,
+       array_length(array_agg(tab0s0||'67', 100000)) AS c67,
+       array_length(array_agg(tab0s0||'68', 100000)) AS c68,
+       array_length(array_agg(tab0s0||'69', 100000)) AS c69,
+       array_length(array_agg(tab0s0||'70', 100000)) AS c70,
+       array_length(array_agg(tab0s0||'71', 100000)) AS c71,
+       array_length(array_agg(tab0s0||'72', 100000)) AS c72,
+       array_length(array_agg(tab0s0||'73', 100000)) AS c73,
+       array_length(array_agg(tab0s0||'74', 100000)) AS c74,
+       array_length(array_agg(tab0s0||'75', 100000)) AS c75,
+       array_length(array_agg(tab0s0||'76', 100000)) AS c76,
+       array_length(array_agg(tab0s0||'77', 100000)) AS c77,
+       array_length(array_agg(tab0s0||'78', 100000)) AS c78,
+       array_length(array_agg(tab0s0||'79', 100000)) AS c79,
+       array_length(array_agg(tab0s0||'80', 100000)) AS c80,
+       array_length(array_agg(tab0s0||'81', 100000)) AS c81,
+       array_length(array_agg(tab0s0||'82', 100000)) AS c82,
+       array_length(array_agg(tab0s0||'83', 100000)) AS c83,
+       array_length(array_agg(tab0s0||'84', 100000)) AS c84,
+       array_length(array_agg(tab0s0||'85', 100000)) AS c85,
+       array_length(array_agg(tab0s0||'86', 100000)) AS c86,
+       array_length(array_agg(tab0s0||'87', 100000)) AS c87,
+       array_length(array_agg(tab0s0||'88', 100000)) AS c88,
+       array_length(array_agg(tab0s0||'89', 100000)) AS c89,
+       array_length(array_agg(tab0s0||'90', 100000)) AS c90,
+       array_length(array_agg(tab0s0||'91', 100000)) AS c91,
+       array_length(array_agg(tab0s0||'92', 100000)) AS c92,
+       array_length(array_agg(tab0s0||'93', 100000)) AS c93,
+       array_length(array_agg(tab0s0||'94', 100000)) AS c94,
+       array_length(array_agg(tab0s0||'95', 100000)) AS c95,
+       array_length(array_agg(tab0s0||'96', 100000)) AS c96,
+       array_length(array_agg(tab0s0||'97', 100000)) AS c97,
+       array_length(array_agg(tab0s0||'98', 100000)) AS c98,
+       array_length(array_agg(tab0s0||'99', 100000)) AS c99,
+       array_length(array_agg(tab0s0||'100', 100000)) AS c100
+FROM test_agg_funcs
+GROUP BY __time;
+Not enough merge buffer memory
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(lower(tab0s0)) AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++--------------------------------------------------------------------------+
+| col                                                                      |
++--------------------------------------------------------------------------+
+| [aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa] |
++--------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(tab0s0 || tab0s0 || tab0s0 || tab0s0 || tab0s0) AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                                                                                                                                                                                                      |
++--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA] |
++--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(length(tab0s0)) AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++--------------------------+
+| col                      |
++--------------------------+
+| [10, 10, 10, 10, 10, 10] |
++--------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(tab0s0, 'Not even a size') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: A02 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(tab0s0, -1) AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: A03 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(tab0s0, 0) AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: A04 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(tab0s0, 1) AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: A05 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(tab0s0, 2147483648) AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(tab0s0, 2147483647) AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++--------------------------------------------------------------------------+
+| col                                                                      |
++--------------------------------------------------------------------------+
+| [AAAAAAAAAA, AAAAAAAAAA, AAAAAAAAAA, AAAAAAAAAA, AAAAAAAAAA, AAAAAAAAAA] |
++--------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(tab0s0, 100000000) AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++--------------------------------------------------------------------------+
+| col                                                                      |
++--------------------------------------------------------------------------+
+| [AAAAAAAAAA, AAAAAAAAAA, AAAAAAAAAA, AAAAAAAAAA, AAAAAAAAAA, AAAAAAAAAA] |
++--------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(tab0s0, 10000000) AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++--------------------------------------------------------------------------+
+| col                                                                      |
++--------------------------------------------------------------------------+
+| [AAAAAAAAAA, AAAAAAAAAA, AAAAAAAAAA, AAAAAAAAAA, AAAAAAAAAA, AAAAAAAAAA] |
++--------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 16 Positive tests: 9 Negative tests: 7
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_string.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_string.iq
new file mode 100644
index 000000000000..05eb97904aec
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_string.iq
@@ -0,0 +1,2235 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaAggFuncs&numMergeBuffers=3
+!set outputformat mysql
+SELECT count(*) cnt
+FROM test_agg_funcs;
++-----+
+| cnt |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array['AAAAAAAAAA',
+             'BBBBBBBBBB'] AS col;
++--------------------------+
+| col                      |
++--------------------------+
+| [AAAAAAAAAA, BBBBBBBBBB] |
++--------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg('AAAAAAAAAA') AS col;
++--------------+
+| col          |
++--------------+
+| [AAAAAAAAAA] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(tab0s0) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 161 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(tab0s0)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(tab0s0), 0) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(tab0s0), 100) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(tab0s0), 1) AS col
+FROM test_agg_funcs
+WHERE tab0s0='BBBBBBBBBB';
++------------+
+| col        |
++------------+
+| BBBBBBBBBB |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(tab0s0), 100) AS col
+FROM test_agg_funcs
+WHERE tab0s0='BBBBBBBBBB';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0s0), 'AAAAAAAAAA') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0s0), array['AAAAAAAAAA', 'BBBBBBBBBB']) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0s0), 'CCCCCCCCCC') AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0s0), array['AAAAAAAAAA', 'CCCCCCCCCC']) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(tab0s0), array['AAAAAAAAAA', 'CCCCCCCCCC']) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(tab0s0), array['CCCCCCCCCC', 'DDDDDDDDDD']) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(tab0s0), array_agg(DISTINCT tab0s0)) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(tab0s0), 'AAAAAAAAAA') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(tab0s0), 'CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(tab0s0), 'AAAAAAAAAA') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(tab0s0), 'CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(array_agg(tab0s0), '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 161 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(tab0s0), '|'), 'AAAAAAAAAA')
+AND contains_string(array_to_string(array_agg(DISTINCT tab0s0), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_prepend('CCCCCCCCCC', array_agg(tab0s0)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 172 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_prepend('CCCCCCCCCC', array_agg(tab0s0))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_append(array_agg(tab0s0), 'CCCCCCCCCC') AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 172 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_append(array_agg(tab0s0), 'CCCCCCCCCC')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(tab0s0), array['CCCCCCCCCC']) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 172 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(tab0s0), array['CCCCCCCCCC'])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(tab0s0), array_agg(tab0s0)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 323 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(tab0s0), array_agg(tab0s0))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  36 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(tab0s0), 0, 1) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++--------------+
+| col          |
++--------------+
+| [AAAAAAAAAA] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(tab0s0), 100, 101) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A32 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(t0.tab0s0) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0s0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A33 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(array_agg(t0.tab0s0), '') AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0s0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A34 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(t0.tab0s0), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0s0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A35 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(t0.tab0s0) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0s0;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A36 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(array_agg(t0.tab0s0), '') AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0s0;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A37 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(t0.tab0s0), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0s0;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array['AAAAAAAAAA',
+             'BBBBBBBBBB'] AS col;
++--------------------------+
+| col                      |
++--------------------------+
+| [AAAAAAAAAA, BBBBBBBBBB] |
++--------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT 'AAAAAAAAAA') AS col;
++--------------+
+| col          |
++--------------+
+| [AAAAAAAAAA] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(DISTINCT tab0s0) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  26 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(DISTINCT tab0s0)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(DISTINCT tab0s0), 0) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(DISTINCT tab0s0), 100) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(DISTINCT tab0s0), 1) AS col
+FROM test_agg_funcs
+WHERE tab0s0='BBBBBBBBBB';
++------------+
+| col        |
++------------+
+| BBBBBBBBBB |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(DISTINCT tab0s0), 100) AS col
+FROM test_agg_funcs
+WHERE tab0s0='BBBBBBBBBB';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0s0), 'AAAAAAAAAA') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0s0), array['AAAAAAAAAA', 'BBBBBBBBBB']) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0s0), 'CCCCCCCCCC') AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0s0), array['AAAAAAAAAA', 'CCCCCCCCCC']) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT tab0s0), array['AAAAAAAAAA', 'CCCCCCCCCC']) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT tab0s0), array['CCCCCCCCCC', 'DDDDDDDDDD']) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT tab0s0), array_agg(DISTINCT tab0s0)) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(DISTINCT tab0s0), 'AAAAAAAAAA') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(DISTINCT tab0s0), 'CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(DISTINCT tab0s0), 'AAAAAAAAAA') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(DISTINCT tab0s0), 'CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(array_agg(DISTINCT tab0s0), '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  26 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(DISTINCT tab0s0), '|'), 'AAAAAAAAAA')
+AND contains_string(array_to_string(array_agg(DISTINCT tab0s0), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_prepend('CCCCCCCCCC', array_agg(DISTINCT tab0s0)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  37 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_prepend('CCCCCCCCCC', array_agg(DISTINCT tab0s0))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_append(array_agg(DISTINCT tab0s0), 'CCCCCCCCCC') AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  37 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_append(array_agg(DISTINCT tab0s0), 'CCCCCCCCCC')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(DISTINCT tab0s0), array['CCCCCCCCCC']) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  37 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT tab0s0), array['CCCCCCCCCC'])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(DISTINCT tab0s0), array_agg(DISTINCT tab0s0)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  53 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT tab0s0), array_agg(DISTINCT tab0s0))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   6 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(DISTINCT tab0s0), 0, 1) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++--------------+
+| col          |
++--------------+
+| [AAAAAAAAAA] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(DISTINCT tab0s0), 100, 101) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(DISTINCT t0.tab0s0) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0s0 IS NOT NULL);
++-----+
+| LEN |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) AS LEN
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.tab0s0), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0s0 IS NOT NULL);
++-----+
+| LEN |
++-----+
+|  20 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(DISTINCT t0.tab0s0), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0s0 IS NOT NULL;
++-----+
+| col |
++-----+
+|  20 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(DISTINCT t0.tab0s0) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0s0);
++-----+
+| LEN |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) AS LEN
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.tab0s0), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0s0);
++-----+
+| LEN |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(DISTINCT t0.tab0s0), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0s0;
++-----+
+| col |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array['AAAAAAAAAA',
+             'BBBBBBBBBB'] AS col;
++--------------------------+
+| col                      |
++--------------------------+
+| [AAAAAAAAAA, BBBBBBBBBB] |
++--------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A02 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT 'AAAAAAAAAA', 100000) AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(DISTINCT tab0s0, 100000) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  26 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(DISTINCT tab0s0, 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(DISTINCT tab0s0, 100000), 0) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(DISTINCT tab0s0, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(DISTINCT tab0s0, 100000), 1) AS col
+FROM test_agg_funcs
+WHERE tab0s0='BBBBBBBBBB';
++------------+
+| col        |
++------------+
+| BBBBBBBBBB |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(DISTINCT tab0s0, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE tab0s0='BBBBBBBBBB';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0s0, 100000), 'AAAAAAAAAA') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0s0, 100000), array['AAAAAAAAAA', 'BBBBBBBBBB']) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0s0, 100000), 'CCCCCCCCCC') AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT tab0s0, 100000), array['AAAAAAAAAA', 'CCCCCCCCCC']) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT tab0s0, 100000), array['AAAAAAAAAA', 'CCCCCCCCCC']) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT tab0s0, 100000), array['CCCCCCCCCC', 'DDDDDDDDDD']) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT tab0s0, 100000), array_agg(DISTINCT tab0s0, 100000)) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(DISTINCT tab0s0, 100000), 'AAAAAAAAAA') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(DISTINCT tab0s0, 100000), 'CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(DISTINCT tab0s0, 100000), 'AAAAAAAAAA') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(DISTINCT tab0s0, 100000), 'CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(array_agg(DISTINCT tab0s0, 100000), '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  26 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(DISTINCT tab0s0, 100000), '|'), 'AAAAAAAAAA')
+AND contains_string(array_to_string(array_agg(DISTINCT tab0s0, 100000), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_prepend('CCCCCCCCCC', array_agg(DISTINCT tab0s0, 100000)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  37 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_prepend('CCCCCCCCCC', array_agg(DISTINCT tab0s0, 100000))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_append(array_agg(DISTINCT tab0s0, 100000), 'CCCCCCCCCC') AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  37 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_append(array_agg(DISTINCT tab0s0, 100000), 'CCCCCCCCCC')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(DISTINCT tab0s0, 100000), array['CCCCCCCCCC']) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  37 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT tab0s0, 100000), array['CCCCCCCCCC'])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(DISTINCT tab0s0, 100000), array_agg(DISTINCT tab0s0, 100000)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  53 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT tab0s0, 100000), array_agg(DISTINCT tab0s0, 100000))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   6 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(DISTINCT tab0s0, 100000), 0, 1) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++--------------+
+| col          |
++--------------+
+| [AAAAAAAAAA] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(DISTINCT tab0s0, 100000), 100, 101) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(DISTINCT t0.tab0s0, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0s0 IS NOT NULL);
++-----+
+| LEN |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) AS LEN
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.tab0s0, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0s0 IS NOT NULL);
++-----+
+| LEN |
++-----+
+|  20 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(DISTINCT t0.tab0s0, 100000), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0s0 IS NOT NULL;
++-----+
+| col |
++-----+
+|  20 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(DISTINCT t0.tab0s0, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0s0);
++-----+
+| LEN |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) AS LEN
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.tab0s0, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0s0);
++-----+
+| LEN |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(DISTINCT t0.tab0s0, 100000), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0s0;
++-----+
+| col |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array['AAAAAAAAAA',
+             'BBBBBBBBBB'] AS col;
++--------------------------+
+| col                      |
++--------------------------+
+| [AAAAAAAAAA, BBBBBBBBBB] |
++--------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A02 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg('AAAAAAAAAA', 100000) AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(tab0s0, 100000) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 161 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(tab0s0, 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(tab0s0, 100000), 0) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(tab0s0, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(tab0s0, 100000), 1) AS col
+FROM test_agg_funcs
+WHERE tab0s0='BBBBBBBBBB';
++------------+
+| col        |
++------------+
+| BBBBBBBBBB |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(tab0s0, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE tab0s0='BBBBBBBBBB';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0s0, 100000), 'AAAAAAAAAA') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0s0, 100000), array['AAAAAAAAAA', 'BBBBBBBBBB']) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0s0, 100000), 'CCCCCCCCCC') AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(tab0s0, 100000), array['AAAAAAAAAA', 'CCCCCCCCCC']) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(tab0s0, 100000), array['AAAAAAAAAA', 'CCCCCCCCCC']) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(tab0s0, 100000), array['CCCCCCCCCC', 'DDDDDDDDDD']) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(tab0s0, 100000), array_agg(DISTINCT tab0s0, 100000)) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(tab0s0, 100000), 'AAAAAAAAAA') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(tab0s0, 100000), 'CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(tab0s0, 100000), 'AAAAAAAAAA') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(tab0s0, 100000), 'CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(array_agg(tab0s0, 100000), '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 161 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(tab0s0, 100000), '|'), 'AAAAAAAAAA')
+AND contains_string(array_to_string(array_agg(DISTINCT tab0s0, 100000), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_prepend('CCCCCCCCCC', array_agg(tab0s0, 100000)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 172 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_prepend('CCCCCCCCCC', array_agg(tab0s0, 100000))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_append(array_agg(tab0s0, 100000), 'CCCCCCCCCC') AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 172 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_append(array_agg(tab0s0, 100000), 'CCCCCCCCCC')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(tab0s0, 100000), array['CCCCCCCCCC']) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 172 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(tab0s0, 100000), array['CCCCCCCCCC'])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(tab0s0, 100000), array_agg(tab0s0, 100000)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 323 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(tab0s0, 100000), array_agg(tab0s0, 100000))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  36 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(tab0s0, 100000), 0, 1) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++--------------+
+| col          |
++--------------+
+| [AAAAAAAAAA] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(tab0s0, 100000), 100, 101) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(t0.tab0s0, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0s0 IS NOT NULL);
++-------+
+| LEN   |
++-------+
+| 42767 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) AS LEN
+FROM
+  (SELECT array_to_string(array_agg(t0.tab0s0, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0s0 IS NOT NULL);
++-------+
+| LEN   |
++-------+
+| 38880 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(t0.tab0s0, 100000), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0s0 IS NOT NULL;
++-------+
+| col   |
++-------+
+| 38880 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(t0.tab0s0, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0s0);
++-------+
+| LEN   |
++-------+
+| 21383 |
+| 21383 |
+|  9719 |
++-------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) AS LEN
+FROM
+  (SELECT array_to_string(array_agg(t0.tab0s0, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0s0);
++-------+
+| LEN   |
++-------+
+| 19440 |
+| 19440 |
+|  7776 |
++-------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(t0.tab0s0, 100000), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0s0;
++-------+
+| col   |
++-------+
+| 19440 |
+| 19440 |
+|  7776 |
++-------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 149 Positive tests: 141 Negative tests: 8
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_timestamp.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_timestamp.iq
new file mode 100644
index 000000000000..beee4073b0cc
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_array_agg_timestamp.iq
@@ -0,0 +1,1750 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaAggFuncs&numMergeBuffers=3
+!set outputformat mysql
+SELECT count(*) cnt
+FROM test_agg_funcs;
++-----+
+| cnt |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[timestamp '2020-01-01 01:01:01.000', timestamp '2020-02-01 01:01:01.000'] AS col;
++--------------------------------------------+
+| col                                        |
++--------------------------------------------+
+| [2020-01-01 01:01:01, 2020-02-01 01:01:01] |
++--------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(timestamp '2020-01-01 01:01:01.000') AS col;
++-----------------------+
+| col                   |
++-----------------------+
+| [2020-01-01 01:01:01] |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(__time) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 251 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(__time)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(__time), 100) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(__time), 100) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-02-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(__time), array[timestamp '2020-01-01 01:01:01.000', timestamp '2020-02-01 01:01:01.000']) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(__time), array[timestamp '2020-01-01 01:01:01.000', timestamp '2020-03-01 01:01:01.000']) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(__time), array[timestamp '2020-01-01 01:01:01.000', timestamp '2020-03-01 01:01:01.000']) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(__time), array[timestamp '2020-03-01 01:01:01.000', timestamp '2020-04-01 01:01:01.000']) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(__time), array_agg(DISTINCT __time)) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(__time), timestamp '2020-01-01 01:01:01.000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(__time), timestamp '2020-03-01 01:01:01.000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(__time), timestamp '2020-01-01 01:01:01.000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(__time), timestamp '2020-03-01 01:01:01.000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(array_agg(__time), '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 251 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(__time), '|'), '1577840461000')
+AND contains_string(array_to_string(array_agg(DISTINCT __time), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(__time), array[timestamp '2020-03-01 01:01:01.000']) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 265 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(__time), array[timestamp '2020-03-01 01:01:01.000'])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(__time), array_agg(__time)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 503 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(__time), array_agg(__time))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  36 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(__time), 0, 1) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------+
+| col                   |
++-----------------------+
+| [2020-01-01 01:01:01] |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(__time), 100, 101) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A24 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(t0.__time)
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.__time IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A25 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(array_agg(t0.__time), '')
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.__time IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A26 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(t0.__time), ''))
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.__time IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A27 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(t0.__time)
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.__time;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A28 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(array_agg(t0.__time), '')
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.__time;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A29 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(t0.__time), ''))
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.__time;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[timestamp '2020-01-01 01:01:01.000', timestamp '2020-02-01 01:01:01.000'] AS col;
++--------------------------------------------+
+| col                                        |
++--------------------------------------------+
+| [2020-01-01 01:01:01, 2020-02-01 01:01:01] |
++--------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT timestamp '2020-01-01 01:01:01.000') AS col;
++-----------------------+
+| col                   |
++-----------------------+
+| [2020-01-01 01:01:01] |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(DISTINCT __time) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(DISTINCT __time)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(DISTINCT __time), 100) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(DISTINCT __time), 100) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-02-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT __time), array[timestamp '2020-01-01 01:01:01.000', timestamp '2020-02-01 01:01:01.000']) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT __time), array[timestamp '2020-01-01 01:01:01.000', timestamp '2020-03-01 01:01:01.000']) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT __time), array[timestamp '2020-01-01 01:01:01.000', timestamp '2020-03-01 01:01:01.000']) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT __time), array[timestamp '2020-03-01 01:01:01.000', timestamp '2020-04-01 01:01:01.000']) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT __time), array_agg(DISTINCT __time)) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(DISTINCT __time), timestamp '2020-01-01 01:01:01.000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(DISTINCT __time), timestamp '2020-03-01 01:01:01.000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(DISTINCT __time), timestamp '2020-01-01 01:01:01.000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(DISTINCT __time), timestamp '2020-03-01 01:01:01.000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(array_agg(DISTINCT __time), '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(DISTINCT __time), '|'), '1577840461000')
+AND contains_string(array_to_string(array_agg(DISTINCT __time), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(DISTINCT __time), array[timestamp '2020-03-01 01:01:01.000']) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  41 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT __time), array[timestamp '2020-03-01 01:01:01.000'])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(DISTINCT __time), array_agg(DISTINCT __time)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  55 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT __time), array_agg(DISTINCT __time))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(DISTINCT __time), 0, 1) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------+
+| col                   |
++-----------------------+
+| [2020-01-01 01:01:01] |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(DISTINCT __time), 100, 101) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(DISTINCT t0.__time) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.__time IS NOT NULL);
++-----+
+| LEN |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) AS LEN
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.__time), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.__time IS NOT NULL);
++-----+
+| LEN |
++-----+
+|  26 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(DISTINCT t0.__time), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.__time IS NOT NULL;
++-----+
+| col |
++-----+
+|  26 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(DISTINCT t0.__time) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.__time);
++-----+
+| LEN |
++-----+
+|  13 |
+|  13 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) AS LEN
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.__time), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.__time);
++-----+
+| LEN |
++-----+
+|  13 |
+|  13 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(DISTINCT t0.__time), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.__time;
++-----+
+| col |
++-----+
+|  13 |
+|  13 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[timestamp '2020-01-01 01:01:01.000', timestamp '2020-02-01 01:01:01.000'] AS col;
++--------------------------------------------+
+| col                                        |
++--------------------------------------------+
+| [2020-01-01 01:01:01, 2020-02-01 01:01:01] |
++--------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A02 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(DISTINCT timestamp '2020-01-01 01:01:01.000', 100000) AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(DISTINCT __time, 100000) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(DISTINCT __time, 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(DISTINCT __time, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(DISTINCT __time, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-02-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT __time, 100000), array[timestamp '2020-01-01 01:01:01.000', timestamp '2020-02-01 01:01:01.000']) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(DISTINCT __time, 100000), array[timestamp '2020-01-01 01:01:01.000', timestamp '2020-03-01 01:01:01.000']) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT __time, 100000), array[timestamp '2020-01-01 01:01:01.000', timestamp '2020-03-01 01:01:01.000']) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT __time, 100000), array[timestamp '2020-03-01 01:01:01.000', timestamp '2020-04-01 01:01:01.000']) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(DISTINCT __time, 100000), array_agg(DISTINCT __time, 100000)) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(DISTINCT __time, 100000), timestamp '2020-01-01 01:01:01.000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(DISTINCT __time, 100000), timestamp '2020-03-01 01:01:01.000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(DISTINCT __time, 100000), timestamp '2020-01-01 01:01:01.000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(DISTINCT __time, 100000), timestamp '2020-03-01 01:01:01.000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(array_agg(DISTINCT __time, 100000), '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(DISTINCT __time, 100000), '|'), '1577840461000')
+AND contains_string(array_to_string(array_agg(DISTINCT __time, 100000), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(DISTINCT __time, 100000), array[timestamp '2020-03-01 01:01:01.000']) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  41 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT __time, 100000), array[timestamp '2020-03-01 01:01:01.000'])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(DISTINCT __time, 100000), array_agg(DISTINCT __time, 100000)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  55 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(DISTINCT __time, 100000), array_agg(DISTINCT __time, 100000))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(DISTINCT __time, 100000), 0, 1) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------+
+| col                   |
++-----------------------+
+| [2020-01-01 01:01:01] |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(DISTINCT __time, 100000), 100, 101) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(DISTINCT t0.__time, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.__time IS NOT NULL);
++-----+
+| LEN |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) AS LEN
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.__time, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.__time IS NOT NULL);
++-----+
+| LEN |
++-----+
+|  26 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(DISTINCT t0.__time, 100000), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.__time IS NOT NULL;
++-----+
+| col |
++-----+
+|  26 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(DISTINCT t0.__time, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.__time);
++-----+
+| LEN |
++-----+
+|  13 |
+|  13 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) AS LEN
+FROM
+  (SELECT array_to_string(array_agg(DISTINCT t0.__time, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.__time);
++-----+
+| LEN |
++-----+
+|  13 |
+|  13 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(DISTINCT t0.__time, 100000), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.__time;
++-----+
+| col |
++-----+
+|  13 |
+|  13 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array[timestamp '2020-01-01 01:01:01.000', timestamp '2020-02-01 01:01:01.000'] AS col;
++--------------------------------------------+
+| col                                        |
++--------------------------------------------+
+| [2020-01-01 01:01:01, 2020-02-01 01:01:01] |
++--------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A02 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_agg(timestamp '2020-01-01 01:01:01.000', 100000);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(__time, 100000) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 251 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_agg(__time, 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(array_agg(__time, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(array_agg(__time, 100000), 100) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-02-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(__time, 100000), array[timestamp '2020-01-01 01:01:01.000', timestamp '2020-02-01 01:01:01.000']) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(array_agg(__time, 100000), array[timestamp '2020-01-01 01:01:01.000', timestamp '2020-03-01 01:01:01.000']) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(__time, 100000), array[timestamp '2020-01-01 01:01:01.000', timestamp '2020-03-01 01:01:01.000']) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(__time, 100000), array[timestamp '2020-03-01 01:01:01.000', timestamp '2020-04-01 01:01:01.000']) AS col
+FROM test_agg_funcs;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(array_agg(__time, 100000), array_agg(__time, 100000)) AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(__time, 100000), timestamp '2020-01-01 01:01:01.000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(array_agg(__time, 100000), timestamp '2020-03-01 01:01:01.000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(__time, 100000), timestamp '2020-01-01 01:01:01.000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(array_agg(__time, 100000), timestamp '2020-03-01 01:01:01.000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(array_agg(__time, 100000), '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 251 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(array_to_string(array_agg(__time, 100000), '|'), '1577840461000')
+AND contains_string(array_to_string(array_agg(__time, 100000), '|'), '|') AS col
+FROM test_agg_funcs;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(__time, 100000), array[timestamp '2020-03-01 01:01:01.000']) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 265 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(__time, 100000), array[timestamp '2020-03-01 01:01:01.000'])) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  19 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_concat(array_agg(__time, 100000), array_agg(__time, 100000)) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 503 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(array_concat(array_agg(__time, 100000), array_agg(__time, 100000))) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  36 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(__time, 100000), 0, 1) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------+
+| col                   |
++-----------------------+
+| [2020-01-01 01:01:01] |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(array_agg(__time, 100000), 100, 101) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(t0.__time, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.__time IS NOT NULL);
++-------+
+| LEN   |
++-------+
+| 81647 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) AS LEN
+FROM
+  (SELECT array_to_string(array_agg(t0.__time, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.__time IS NOT NULL);
++-------+
+| LEN   |
++-------+
+| 75816 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(t0.__time, 100000), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.__time IS NOT NULL;
++-------+
+| col   |
++-------+
+| 75816 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(array_to_string(col, '|')) AS LEN
+FROM
+  (SELECT array_agg(t0.__time, 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.__time);
++-------+
+| LEN   |
++-------+
+| 40823 |
+| 40823 |
++-------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) AS LEN
+FROM
+  (SELECT array_to_string(array_agg(t0.__time, 100000), '') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.__time);
++-------+
+| LEN   |
++-------+
+| 37908 |
+| 37908 |
++-------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(array_to_string(array_agg(t0.__time, 100000), '')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.__time;
++-------+
+| col   |
++-------+
+| 37908 |
+| 37908 |
++-------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 117 Positive tests: 109 Negative tests: 8
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_double.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_double.iq
new file mode 100644
index 000000000000..9fb8a79b9e78
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_double.iq
@@ -0,0 +1,4597 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaAggFuncs&numMergeBuffers=3
+!set outputformat mysql
+SELECT count(*) cnt
+FROM test_agg_funcs;
++-----+
+| cnt |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(111.1111111, '|') AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(tab0d0, '|') AS col
+   FROM test_agg_funcs)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0d0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0d0 IS NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(tab0d0, '|') || '-3333333333' AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT '3333333333-' || string_agg(tab0d0, '|') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(tab0d0, ',') || '-' || string_agg(tab0d0, '|') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT concat(string_agg(tab0d0, ','), '-', string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat(string_agg(tab0d0, '|'), '-3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat('3333333333-', string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat(string_agg(tab0d0, ','), string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_format('%s-%s', string_agg(tab0d0, ','), string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT char_length(string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT character_length(string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT character_length(string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lower(string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(tab0d0, '|'), 16) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(tab0d0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(tab0d0, '|')
+                FROM 2) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT regexp_extract(string_agg(tab0d0, '|'), '13\.') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(tab0d0, '|'), '14\.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(tab0d0, '|'), '13\.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(tab0d0, '|'), '14\.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(tab0d0, '|'), '111.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(tab0d0, '|'), '222.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(tab0d0, '|'), '111.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(tab0d0, '|'), '222.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT replace(string_agg(tab0d0, '|'), '111.', '3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT replace(string_agg(tab0d0, '|'), '4444444444', '3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(tab0d0, '|'), '111.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(tab0d0, '|'), '|4444444444') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT substring(string_agg(tab0d0, '|'), 1) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT substring(string_agg(tab0d0, '|'), 4, 100) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(BOTH
+               FROM string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(LEADING
+               FROM string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(TRAILING
+               FROM string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(BOTH '1'
+               FROM string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(LEADING '1'
+               FROM string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(TRAILING '1'
+               FROM string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT btrim(string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT btrim(string_agg(tab0d0, '|'), '1') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT ltrim(string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT ltrim(string_agg(tab0d0, '|'), '1') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rtrim(string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rtrim(string_agg(tab0d0, '|'), '1') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT upper(string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT reverse(string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0d0, '|'), -1) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0d0, '|'), 0) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT repeat(string_agg(tab0d0, '|'), 2) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A51 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(tab0d0, '|'), 4) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(tab0d0, '|'), 4, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(tab0d0, '|'), 500) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(tab0d0, '|'), 500, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(tab0d0, '|'), 4) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(tab0d0, '|'), 4, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(tab0d0, '|'), 500) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A58 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(tab0d0, '|'), 500, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A59 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(t0.tab0d0, '|') AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0d0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A60 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(t0.tab0d0, '|')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0d0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A61 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(t0.tab0d0, '|') AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0d0;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A62 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(t0.tab0d0, '|')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0d0;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT 111.1111111, '|') AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT tab0d0, '|') AS col
+   FROM test_agg_funcs)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0d0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0d0 IS NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT tab0d0, '|') || '-3333333333' AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT '3333333333-' || string_agg(DISTINCT tab0d0, '|') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT tab0d0, ',') || '-' || string_agg(tab0d0, '|') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT concat(string_agg(tab0d0, ','), '-', string_agg(DISTINCT tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat(string_agg(DISTINCT tab0d0, '|'), '-3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat('3333333333-', string_agg(DISTINCT tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat(string_agg(tab0d0, ','), string_agg(DISTINCT tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_format('%s-%s', string_agg(DISTINCT tab0d0, ','), string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(DISTINCT tab0d0, '|')) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT char_length(string_agg(DISTINCT tab0d0, '|')) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT character_length(string_agg(DISTINCT tab0d0, '|')) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT character_length(string_agg(DISTINCT tab0d0, '|')) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lower(string_agg(DISTINCT tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(DISTINCT tab0d0, '|'), 16) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(DISTINCT tab0d0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(DISTINCT tab0d0, '|')
+                FROM 2) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT regexp_extract(string_agg(DISTINCT tab0d0, '|'), '13\.') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(DISTINCT tab0d0, '|'), '14\.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT tab0d0, '|'), '13\.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT tab0d0, '|'), '14\.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT tab0d0, '|'), '111.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT tab0d0, '|'), '222.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT tab0d0, '|'), '111.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT tab0d0, '|'), '222.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT replace(string_agg(DISTINCT tab0d0, '|'), '111.', '3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT replace(string_agg(DISTINCT tab0d0, '|'), '4444444444', '3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT tab0d0, '|'), '111.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT tab0d0, '|'), '4444444444') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT substring(string_agg(DISTINCT tab0d0, '|'), 1) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT substring(string_agg(DISTINCT tab0d0, '|'), 1, 100) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(BOTH
+               FROM string_agg(DISTINCT tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(LEADING
+               FROM string_agg(DISTINCT tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(TRAILING
+               FROM string_agg(DISTINCT tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH '1234567890.'
+            FROM string_agg(DISTINCT tab0d0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING '1234567890.'
+            FROM string_agg(DISTINCT tab0d0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING '1234567890.'
+            FROM string_agg(DISTINCT tab0d0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT btrim(string_agg(DISTINCT tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(DISTINCT tab0d0, '|'), '1234567890.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT ltrim(string_agg(DISTINCT tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(DISTINCT tab0d0, '|'), '1234567890.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rtrim(string_agg(DISTINCT tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(DISTINCT tab0d0, '|'), '1234567890.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT upper(string_agg(DISTINCT tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT reverse(string_agg(DISTINCT tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0d0, '|'), -1) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0d0, '|'), 0) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT repeat(string_agg(DISTINCT tab0d0, '|'), 2) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A51 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(DISTINCT tab0d0, '|'), 4) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(DISTINCT tab0d0, '|'), 4, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(DISTINCT tab0d0, '|'), 500) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(DISTINCT tab0d0, '|'), 500, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(DISTINCT tab0d0, '|'), 4) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(DISTINCT tab0d0, '|'), 4, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(DISTINCT tab0d0, '|'), 500) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A58 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(DISTINCT tab0d0, '|'), 500, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A59 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT t0.tab0d0, '|') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0d0 IS NOT NULL)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A60 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(DISTINCT t0.tab0d0, '|')) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0d0 IS NOT NULL)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A61 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT t0.tab0d0, '|') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0d0)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A62 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(DISTINCT t0.tab0d0, '|')) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0d0)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT 111.1111111, '|', 100000) AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT tab0d0, '|', 100000) AS col
+   FROM test_agg_funcs)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0d0, '|', 100000) AS col
+FROM test_agg_funcs
+WHERE tab0d0 IS NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT tab0d0, '|', 100000) || '-3333333333' AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT '3333333333-' || string_agg(DISTINCT tab0d0, '|', 100000) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT tab0d0, ',', 100000) || '-' || string_agg(tab0d0, '|') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT concat(string_agg(tab0d0, ','), '-', string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat(string_agg(DISTINCT tab0d0, '|', 100000), '-3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat('3333333333-', string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat(string_agg(tab0d0, ','), string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_format('%s-%s', string_agg(DISTINCT tab0d0, ',', 100000), string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT char_length(string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT character_length(string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT character_length(string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lower(string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(DISTINCT tab0d0, '|', 100000), 16) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(DISTINCT tab0d0, '|', 100000)
+                FROM 2) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT regexp_extract(string_agg(DISTINCT tab0d0, '|', 100000), '13\.') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(DISTINCT tab0d0, '|', 100000), '14\.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT tab0d0, '|', 100000), '13\.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT tab0d0, '|', 100000), '14\.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT tab0d0, '|', 100000), '111.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT tab0d0, '|', 100000), '222.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT tab0d0, '|', 100000), '111.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT tab0d0, '|', 100000), '222.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT replace(string_agg(DISTINCT tab0d0, '|', 100000), '111.', '3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT replace(string_agg(DISTINCT tab0d0, '|', 100000), '4444444444', '3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT tab0d0, '|', 100000), '111.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT tab0d0, '|', 100000), '4444444444') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT substring(string_agg(DISTINCT tab0d0, '|', 100000), 1) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT substring(string_agg(DISTINCT tab0d0, '|', 100000), 1, 100) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(BOTH
+               FROM string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(LEADING
+               FROM string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(TRAILING
+               FROM string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH '1234567890.'
+            FROM string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING '1234567890.'
+            FROM string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING '1234567890.'
+            FROM string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT btrim(string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(DISTINCT tab0d0, '|', 100000), '1234567890.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT ltrim(string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(DISTINCT tab0d0, '|', 100000), '1234567890.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rtrim(string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(DISTINCT tab0d0, '|', 100000), '1234567890.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT upper(string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT reverse(string_agg(DISTINCT tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0d0, '|', 100000), -1) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0d0, '|', 100000), 0) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT repeat(string_agg(DISTINCT tab0d0, '|', 100000), 2) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A51 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(DISTINCT tab0d0, '|', 100000), 4) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(DISTINCT tab0d0, '|', 100000), 4, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(DISTINCT tab0d0, '|', 100000), 500) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(DISTINCT tab0d0, '|', 100000), 500, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(DISTINCT tab0d0, '|', 100000), 4) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT tab0d0, '|', 100000), 4, '3') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++------+
+| col  |
++------+
+| 111. |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(DISTINCT tab0d0, '|', 100000), 500) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A58 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(DISTINCT tab0d0, '|', 100000), 500, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A59 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT t0.tab0d0, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0d0 IS NOT NULL)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A60 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(DISTINCT t0.tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0d0 IS NOT NULL)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A61 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT t0.tab0d0, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0d0)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A62 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(DISTINCT t0.tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0d0)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(111.1111111, '|', 100000) AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(tab0d0, '|', 100000) AS col
+   FROM test_agg_funcs)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(tab0d0, '|', 100000) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0 IS NULL)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(tab0d0, '|', 100000) || '-3333333333' AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT '3333333333-' || string_agg(tab0d0, '|', 100000) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(tab0d0, ',', 100000) || '-' || string_agg(tab0d0, '|') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT concat(string_agg(tab0d0, ','), '-', string_agg(tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat(string_agg(tab0d0, '|', 100000), '-3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat('3333333333-', string_agg(tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat(string_agg(tab0d0, ',', 100000), string_agg(tab0d0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_format('%s-%s', string_agg(tab0d0, ','), string_agg(tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT char_length(string_agg(tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT character_length(string_agg(tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT character_length(string_agg(tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lower(string_agg(tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(tab0d0, '|', 100000), 16) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(tab0d0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(tab0d0, '|', 100000)
+                FROM 2) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT regexp_extract(string_agg(tab0d0, '|', 100000), '13\.') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(tab0d0, '|', 100000), '14\.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(tab0d0, '|', 100000), '13\.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(tab0d0, '|', 100000), '14\.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(tab0d0, '|', 100000), '111.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(tab0d0, '|', 100000), '222.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(tab0d0, '|', 100000), '111.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(tab0d0, '|', 100000), '222.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT replace(string_agg(tab0d0, '|', 100000), '111.', '3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT replace(string_agg(tab0d0, '|', 100000), '4444444444', '3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(tab0d0, '|', 100000), '111.') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(tab0d0, '|', 100000), '|4444444444') AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT substring(string_agg(tab0d0, '|', 100000), 1) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT substring(string_agg(tab0d0, '|', 100000), 4, 100) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(BOTH
+               FROM string_agg(tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(LEADING
+               FROM string_agg(tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(TRAILING
+               FROM string_agg(tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(BOTH '1'
+               FROM string_agg(tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(LEADING '1'
+               FROM string_agg(tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(TRAILING '1'
+               FROM string_agg(tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT btrim(string_agg(tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT btrim(string_agg(tab0d0, '|', 100000), '1') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT ltrim(string_agg(tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT ltrim(string_agg(tab0d0, '|', 100000), '1') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rtrim(string_agg(tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rtrim(string_agg(tab0d0, '|', 100000), '1') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT upper(string_agg(tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT reverse(string_agg(tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0d0, '|', 100000), -1) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0d0, '|', 100000), 0) AS col
+FROM test_agg_funcs
+WHERE tab0d0>111
+  AND tab0d0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT repeat(string_agg(tab0d0, '|', 100000), 2) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A51 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(tab0d0, '|', 100000), 4) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(tab0d0, '|', 100000), 4, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(tab0d0, '|', 100000), 500) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(tab0d0, '|', 100000), 500, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(tab0d0, '|', 100000), 4) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(tab0d0, '|', 100000), 4, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(tab0d0, '|', 100000), 500) AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A58 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(tab0d0, '|', 100000), 500, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0d0>111
+     AND tab0d0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A59 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(t0.tab0d0, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0d0 IS NOT NULL)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A60 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(t0.tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0d0 IS NOT NULL)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A61 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(t0.tab0d0, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0d0)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A62 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(t0.tab0d0, '|', 100000)) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0d0)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 249 Positive tests: 241 Negative tests: 8
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_float.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_float.iq
new file mode 100644
index 000000000000..d2b1a5207931
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_float.iq
@@ -0,0 +1,4597 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaAggFuncs&numMergeBuffers=3
+!set outputformat mysql
+SELECT count(*) cnt
+FROM test_agg_funcs;
++-----+
+| cnt |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(11.1111111, '|') AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(tab0f0, '|') AS col
+   FROM test_agg_funcs)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0f0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0f0 IS NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(tab0f0, '|') || '-3333333333' AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT '3333333333-' || string_agg(tab0f0, '|') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(tab0f0, ',') || '-' || string_agg(tab0f0, '|') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT concat(string_agg(tab0f0, ','), '-', string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat(string_agg(tab0f0, '|'), '-3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat('3333333333-', string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat(string_agg(tab0f0, ','), string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_format('%s-%s', string_agg(tab0f0, ','), string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT char_length(string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT character_length(string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT character_length(string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lower(string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(tab0f0, '|'), 16) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(tab0f0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(tab0f0, '|')
+                FROM 2) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT regexp_extract(string_agg(tab0f0, '|'), '13\.') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(tab0f0, '|'), '14\.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(tab0f0, '|'), '13\.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(tab0f0, '|'), '14\.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(tab0f0, '|'), '11.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(tab0f0, '|'), '22.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(tab0f0, '|'), '11.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(tab0f0, '|'), '22.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT replace(string_agg(tab0f0, '|'), '11.', '3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT replace(string_agg(tab0f0, '|'), '4444444444', '3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(tab0f0, '|'), '11.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(tab0f0, '|'), '|4444444444') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT substring(string_agg(tab0f0, '|'), 1) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT substring(string_agg(tab0f0, '|'), 4, 100) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(BOTH
+               FROM string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(LEADING
+               FROM string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(TRAILING
+               FROM string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(BOTH '1'
+               FROM string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(LEADING '1'
+               FROM string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(TRAILING '1'
+               FROM string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT btrim(string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT btrim(string_agg(tab0f0, '|'), '1') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT ltrim(string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT ltrim(string_agg(tab0f0, '|'), '1') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rtrim(string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rtrim(string_agg(tab0f0, '|'), '1') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT upper(string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT reverse(string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0f0, '|'), -1) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0f0, '|'), 0) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT repeat(string_agg(tab0f0, '|'), 2) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A51 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(tab0f0, '|'), 4) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(tab0f0, '|'), 4, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(tab0f0, '|'), 500) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(tab0f0, '|'), 500, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(tab0f0, '|'), 4) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(tab0f0, '|'), 4, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(tab0f0, '|'), 500) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A58 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(tab0f0, '|'), 500, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A59 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(t0.tab0f0, '|') AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0f0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A60 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(t0.tab0f0, '|')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0f0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A61 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(t0.tab0f0, '|') AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0f0;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A62 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(t0.tab0f0, '|')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0f0;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT 11.1111111, '|') AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT tab0f0, '|') AS col
+   FROM test_agg_funcs)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0f0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0f0 IS NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT tab0f0, '|') || '-3333333333' AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT '3333333333-' || string_agg(DISTINCT tab0f0, '|') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT tab0f0, ',') || '-' || string_agg(tab0f0, '|') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT concat(string_agg(tab0f0, ','), '-', string_agg(DISTINCT tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat(string_agg(DISTINCT tab0f0, '|'), '-3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat('3333333333-', string_agg(DISTINCT tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat(string_agg(tab0f0, ','), string_agg(DISTINCT tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_format('%s-%s', string_agg(DISTINCT tab0f0, ','), string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(DISTINCT tab0f0, '|')) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT char_length(string_agg(DISTINCT tab0f0, '|')) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT character_length(string_agg(DISTINCT tab0f0, '|')) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT character_length(string_agg(DISTINCT tab0f0, '|')) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lower(string_agg(DISTINCT tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(DISTINCT tab0f0, '|'), 16) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(DISTINCT tab0f0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(DISTINCT tab0f0, '|')
+                FROM 2) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT regexp_extract(string_agg(DISTINCT tab0f0, '|'), '13\.') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(DISTINCT tab0f0, '|'), '14\.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT tab0f0, '|'), '13\.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT tab0f0, '|'), '14\.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT tab0f0, '|'), '11.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT tab0f0, '|'), '22.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT tab0f0, '|'), '11.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT tab0f0, '|'), '22.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT replace(string_agg(DISTINCT tab0f0, '|'), '11.', '3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT replace(string_agg(DISTINCT tab0f0, '|'), '4444444444', '3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT tab0f0, '|'), '11.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT tab0f0, '|'), '4444444444') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT substring(string_agg(DISTINCT tab0f0, '|'), 1) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT substring(string_agg(DISTINCT tab0f0, '|'), 1, 100) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(BOTH
+               FROM string_agg(DISTINCT tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(LEADING
+               FROM string_agg(DISTINCT tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(TRAILING
+               FROM string_agg(DISTINCT tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH '1234567890.'
+            FROM string_agg(DISTINCT tab0f0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING '1234567890.'
+            FROM string_agg(DISTINCT tab0f0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING '1234567890.'
+            FROM string_agg(DISTINCT tab0f0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT btrim(string_agg(DISTINCT tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(DISTINCT tab0f0, '|'), '1234567890.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT ltrim(string_agg(DISTINCT tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(DISTINCT tab0f0, '|'), '1234567890.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rtrim(string_agg(DISTINCT tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(DISTINCT tab0f0, '|'), '1234567890.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT upper(string_agg(DISTINCT tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT reverse(string_agg(DISTINCT tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0f0, '|'), -1) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0f0, '|'), 0) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT repeat(string_agg(DISTINCT tab0f0, '|'), 2) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A51 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(DISTINCT tab0f0, '|'), 4) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(DISTINCT tab0f0, '|'), 4, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(DISTINCT tab0f0, '|'), 500) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(DISTINCT tab0f0, '|'), 500, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(DISTINCT tab0f0, '|'), 4) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(DISTINCT tab0f0, '|'), 4, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(DISTINCT tab0f0, '|'), 500) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A58 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(DISTINCT tab0f0, '|'), 500, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A59 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT t0.tab0f0, '|') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0f0 IS NOT NULL)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A60 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(DISTINCT t0.tab0f0, '|')) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0f0 IS NOT NULL)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A61 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT t0.tab0f0, '|') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0f0)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A62 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(DISTINCT t0.tab0f0, '|')) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0f0)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT 11.1111111, '|', 100000) AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT tab0f0, '|', 100000) AS col
+   FROM test_agg_funcs)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0f0, '|', 100000) AS col
+FROM test_agg_funcs
+WHERE tab0f0 IS NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT tab0f0, '|', 100000) || '-3333333333' AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT '3333333333-' || string_agg(DISTINCT tab0f0, '|', 100000) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT tab0f0, ',', 100000) || '-' || string_agg(tab0f0, '|') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT concat(string_agg(tab0f0, ','), '-', string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat(string_agg(DISTINCT tab0f0, '|', 100000), '-3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat('3333333333-', string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat(string_agg(tab0f0, ','), string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_format('%s-%s', string_agg(DISTINCT tab0f0, ',', 100000), string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT char_length(string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT character_length(string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT character_length(string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lower(string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(DISTINCT tab0f0, '|', 100000), 16) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(DISTINCT tab0f0, '|', 100000)
+                FROM 2) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT regexp_extract(string_agg(DISTINCT tab0f0, '|', 100000), '13\.') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(DISTINCT tab0f0, '|', 100000), '14\.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT tab0f0, '|', 100000), '13\.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT tab0f0, '|', 100000), '14\.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT tab0f0, '|', 100000), '11.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT tab0f0, '|', 100000), '22.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT tab0f0, '|', 100000), '11.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT tab0f0, '|', 100000), '22.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT replace(string_agg(DISTINCT tab0f0, '|', 100000), '11.', '3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT replace(string_agg(DISTINCT tab0f0, '|', 100000), '4444444444', '3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT tab0f0, '|', 100000), '11.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT tab0f0, '|', 100000), '4444444444') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT substring(string_agg(DISTINCT tab0f0, '|', 100000), 1) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT substring(string_agg(DISTINCT tab0f0, '|', 100000), 1, 100) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(BOTH
+               FROM string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(LEADING
+               FROM string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(TRAILING
+               FROM string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH '1234567890.'
+            FROM string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING '1234567890.'
+            FROM string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING '1234567890.'
+            FROM string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT btrim(string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(DISTINCT tab0f0, '|', 100000), '1234567890.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT ltrim(string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(DISTINCT tab0f0, '|', 100000), '1234567890.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rtrim(string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(DISTINCT tab0f0, '|', 100000), '1234567890.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT upper(string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT reverse(string_agg(DISTINCT tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0f0, '|', 100000), -1) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0f0, '|', 100000), 0) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT repeat(string_agg(DISTINCT tab0f0, '|', 100000), 2) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A51 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(DISTINCT tab0f0, '|', 100000), 4) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(DISTINCT tab0f0, '|', 100000), 4, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(DISTINCT tab0f0, '|', 100000), 500) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(DISTINCT tab0f0, '|', 100000), 500, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(DISTINCT tab0f0, '|', 100000), 4) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT tab0f0, '|', 100000), 4, '3') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(DISTINCT tab0f0, '|', 100000), 500) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A58 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(DISTINCT tab0f0, '|', 100000), 500, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A59 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT t0.tab0f0, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0f0 IS NOT NULL)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A60 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(DISTINCT t0.tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0f0 IS NOT NULL)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A61 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(DISTINCT t0.tab0f0, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0f0)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A62 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(DISTINCT t0.tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0f0)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(11.1111111, '|', 100000) AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(tab0f0, '|', 100000) AS col
+   FROM test_agg_funcs)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(tab0f0, '|', 100000) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0 IS NULL)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(tab0f0, '|', 100000) || '-3333333333' AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT '3333333333-' || string_agg(tab0f0, '|', 100000) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(tab0f0, ',', 100000) || '-' || string_agg(tab0f0, '|') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT concat(string_agg(tab0f0, ','), '-', string_agg(tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat(string_agg(tab0f0, '|', 100000), '-3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat('3333333333-', string_agg(tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT textcat(string_agg(tab0f0, ',', 100000), string_agg(tab0f0, '|')) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_format('%s-%s', string_agg(tab0f0, ','), string_agg(tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT char_length(string_agg(tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT character_length(string_agg(tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT character_length(string_agg(tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lower(string_agg(tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(tab0f0, '|', 100000), 16) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(tab0f0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(tab0f0, '|', 100000)
+                FROM 2) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT regexp_extract(string_agg(tab0f0, '|', 100000), '13\.') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(tab0f0, '|', 100000), '14\.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(tab0f0, '|', 100000), '13\.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(tab0f0, '|', 100000), '14\.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(tab0f0, '|', 100000), '11.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(tab0f0, '|', 100000), '22.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(tab0f0, '|', 100000), '11.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(tab0f0, '|', 100000), '22.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT replace(string_agg(tab0f0, '|', 100000), '11.', '3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT replace(string_agg(tab0f0, '|', 100000), '4444444444', '3333333333') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(tab0f0, '|', 100000), '11.') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(tab0f0, '|', 100000), '|4444444444') AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT substring(string_agg(tab0f0, '|', 100000), 1) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT substring(string_agg(tab0f0, '|', 100000), 4, 100) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(BOTH
+               FROM string_agg(tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(LEADING
+               FROM string_agg(tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(TRAILING
+               FROM string_agg(tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(BOTH '1'
+               FROM string_agg(tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(LEADING '1'
+               FROM string_agg(tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT trim(TRAILING '1'
+               FROM string_agg(tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT btrim(string_agg(tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT btrim(string_agg(tab0f0, '|', 100000), '1') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT ltrim(string_agg(tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT ltrim(string_agg(tab0f0, '|', 100000), '1') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rtrim(string_agg(tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rtrim(string_agg(tab0f0, '|', 100000), '1') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT upper(string_agg(tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT reverse(string_agg(tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0f0, '|', 100000), -1) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0f0, '|', 100000), 0) AS col
+FROM test_agg_funcs
+WHERE tab0f0>111
+  AND tab0f0<222;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT repeat(string_agg(tab0f0, '|', 100000), 2) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A51 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(tab0f0, '|', 100000), 4) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(tab0f0, '|', 100000), 4, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(tab0f0, '|', 100000), 500) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT lpad(string_agg(tab0f0, '|', 100000), 500, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(tab0f0, '|', 100000), 4) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(tab0f0, '|', 100000), 4, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(tab0f0, '|', 100000), 500) AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A58 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT rpad(string_agg(tab0f0, '|', 100000), 500, '3') AS col
+   FROM test_agg_funcs
+   WHERE tab0f0>111
+     AND tab0f0<222)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A59 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(t0.tab0f0, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0f0 IS NOT NULL)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A60 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(t0.tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0f0 IS NOT NULL)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A61 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT string_agg(t0.tab0f0, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0f0)
+WHERE col != 'ABCD'
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A62 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT length(string_agg(t0.tab0f0, '|', 100000)) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0f0)
+WHERE col != 99999
+  OR col IS NULL;
++-----+
+| cnt |
++-----+
+|   3 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 249 Positive tests: 241 Negative tests: 8
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_long.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_long.iq
new file mode 100644
index 000000000000..18437d53c545
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_long.iq
@@ -0,0 +1,3753 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaAggFuncs&numMergeBuffers=3
+!set outputformat mysql
+SELECT count(*) cnt
+FROM test_agg_funcs;
++-----+
+| cnt |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(1111111111, '|') AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(tab0l0, '|') AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0l0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0l0 IS NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0l0, '|') || '-3333333333' AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111-3333333333 |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT '3333333333-' || string_agg(tab0l0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| 3333333333-1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0l0, ',') || '-' || string_agg(tab0l0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                 |
++-------------------------------------------------------------------------------------------------------------------------------------+
+| 1111111111,1111111111,1111111111,1111111111,1111111111,1111111111-1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(string_agg(tab0l0, ','), '-', string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                 |
++-------------------------------------------------------------------------------------------------------------------------------------+
+| 1111111111,1111111111,1111111111,1111111111,1111111111,1111111111-1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(tab0l0, '|'), '-3333333333') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111-3333333333 |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat('3333333333-', string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| 3333333333-1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(tab0l0, ','), string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                |
++------------------------------------------------------------------------------------------------------------------------------------+
+| 1111111111,1111111111,1111111111,1111111111,1111111111,11111111111111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_format('%s-%s', string_agg(tab0l0, ','), string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                 |
++-------------------------------------------------------------------------------------------------------------------------------------+
+| 1111111111,1111111111,1111111111,1111111111,1111111111,1111111111-1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(tab0l0, '|'), 16) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('|1' IN string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|  11 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('|1' IN string_agg(tab0l0, '|')
+                FROM 12) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|  22 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(tab0l0, '|'), '110\|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(tab0l0, '|'), '210\|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(tab0l0, '|'), '110\|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(tab0l0, '|'), '210\|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(tab0l0, '|'), '1111111111|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(tab0l0, '|'), '2222222222|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(tab0l0, '|'), '1111111111|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(tab0l0, '|'), '2222222222|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(tab0l0, '|'), '1111111111', '3333333333') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 3333333333|3333333333|3333333333|3333333333|3333333333|3333333333 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(tab0l0, '|'), '4444444444', '3333333333') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(tab0l0, '|'), '|1111111111') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|  11 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(tab0l0, '|'), '|4444444444') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(tab0l0, '|'), 12) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++--------------------------------------------------------+
+| col                                                    |
++--------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111 |
++--------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(tab0l0, '|'), 12, 11) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------+
+| col         |
++-------------+
+| 1111111111| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH
+            FROM string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING
+            FROM string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING
+            FROM string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH '1'
+            FROM string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------------------------------+
+| col                                           |
++-----------------------------------------------+
+| |1111111111|1111111111|1111111111|1111111111| |
++-----------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING '1'
+            FROM string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++---------------------------------------------------------+
+| col                                                     |
++---------------------------------------------------------+
+| |1111111111|1111111111|1111111111|1111111111|1111111111 |
++---------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING '1'
+            FROM string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++---------------------------------------------------------+
+| col                                                     |
++---------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111| |
++---------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(tab0l0, '|'), '1') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------------------------------+
+| col                                           |
++-----------------------------------------------+
+| |1111111111|1111111111|1111111111|1111111111| |
++-----------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(tab0l0, '|'), '1') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++---------------------------------------------------------+
+| col                                                     |
++---------------------------------------------------------+
+| |1111111111|1111111111|1111111111|1111111111|1111111111 |
++---------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(tab0l0, '|'), '1') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++---------------------------------------------------------+
+| col                                                     |
++---------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111| |
++---------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0l0, '|'), -1) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0l0, '|'), 0) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0l0, '|'), 2) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                |
++------------------------------------------------------------------------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|11111111111111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A51 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(tab0l0, '|'), 11) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------+
+| col         |
++-------------+
+| 1111111111| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(tab0l0, '|'), 11, '3') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------+
+| col         |
++-------------+
+| 1111111111| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(tab0l0, '|'), 75) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+|           1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(tab0l0, '|'), 75, '3') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+| 33333333331111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(tab0l0, '|'), 11) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------+
+| col         |
++-------------+
+| 1111111111| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(tab0l0, '|'), 11, '3') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------+
+| col         |
++-------------+
+| 1111111111| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(tab0l0, '|'), 75) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111           |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A58 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(tab0l0, '|'), 75, '3') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|11111111113333333333 |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A59 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(t0.tab0l0, '|') AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0l0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A60 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(t0.tab0l0, '|')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0l0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A61 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(t0.tab0l0, '|') AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0l0;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A62 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(t0.tab0l0, '|')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0l0;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT 1111111111, '|') AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(DISTINCT tab0l0, '|') AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0l0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0l0 IS NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT tab0l0, '|') || '-3333333333' AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------+
+| col                   |
++-----------------------+
+| 1111111111-3333333333 |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT '3333333333-' || string_agg(DISTINCT tab0l0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------+
+| col                   |
++-----------------------+
+| 3333333333-1111111111 |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT tab0l0, ',') || '-' || string_agg(tab0l0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| 1111111111-1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(string_agg(tab0l0, ','), '-', string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| 1111111111,1111111111,1111111111,1111111111,1111111111,1111111111-1111111111 |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(DISTINCT tab0l0, '|'), '-3333333333') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------+
+| col                   |
++-----------------------+
+| 1111111111-3333333333 |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat('3333333333-', string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------+
+| col                   |
++-----------------------+
+| 3333333333-1111111111 |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(tab0l0, ','), string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+| 1111111111,1111111111,1111111111,1111111111,1111111111,11111111111111111111 |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_format('%s-%s', string_agg(DISTINCT tab0l0, ','), string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| 1111111111-1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(DISTINCT tab0l0, '|'), 16) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------+
+| col         |
++-------------+
+| 73300775185 |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(DISTINCT tab0l0, '|')
+                FROM 2) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(DISTINCT tab0l0, '|'), '110') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(DISTINCT tab0l0, '|'), '210') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT tab0l0, '|'), '110') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT tab0l0, '|'), '210') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT tab0l0, '|'), '1111111111') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT tab0l0, '|'), '2222222222') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT tab0l0, '|'), '1111111111') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT tab0l0, '|'), '2222222222') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(DISTINCT tab0l0, '|'), '1111111111', '3333333333') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 3333333333 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(DISTINCT tab0l0, '|'), '4444444444', '3333333333') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT tab0l0, '|'), '1111111111') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT tab0l0, '|'), '4444444444') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(DISTINCT tab0l0, '|'), 10) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+| 1   |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(DISTINCT tab0l0, '|'), 10, 100) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+| 1   |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH
+            FROM string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING
+            FROM string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING
+            FROM string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH '1'
+            FROM string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING '1'
+            FROM string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING '1'
+            FROM string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(DISTINCT tab0l0, '|'), '1') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(DISTINCT tab0l0, '|'), '1') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(DISTINCT tab0l0, '|'), '1') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(string_agg(DISTINCT tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0l0, '|'), -1) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0l0, '|'), 0) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0l0, '|'), 2) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++----------------------+
+| col                  |
++----------------------+
+| 11111111111111111111 |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A51 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT tab0l0, '|'), 5) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| 11111 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT tab0l0, '|'), 5, '3') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| 11111 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT tab0l0, '|'), 20) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++----------------------+
+| col                  |
++----------------------+
+|           1111111111 |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT tab0l0, '|'), 20, '3') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++----------------------+
+| col                  |
++----------------------+
+| 33333333331111111111 |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT tab0l0, '|'), 5) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| 11111 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT tab0l0, '|'), 5, '3') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| 11111 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT tab0l0, '|'), 20) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++----------------------+
+| col                  |
++----------------------+
+| 1111111111           |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A58 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT tab0l0, '|'), 20, '3') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++----------------------+
+| col                  |
++----------------------+
+| 11111111113333333333 |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A59 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(DISTINCT t0.tab0l0, '|') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0l0 IS NOT NULL);
++-----+
+| LEN |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A60 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(DISTINCT t0.tab0l0, '|')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0l0 IS NOT NULL;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A61 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(DISTINCT t0.tab0l0, '|') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0l0);
++-----+
+| LEN |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A62 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(DISTINCT t0.tab0l0, '|')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0l0;
++-----+
+| col |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT 1111111111, '|', 100000) AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(DISTINCT tab0l0, '|', 100000) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT tab0l0, '|', 100000) AS col
+FROM test_agg_funcs
+WHERE tab0l0 IS NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT tab0l0, '|', 100000) || '-3333333333' AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------+
+| col                   |
++-----------------------+
+| 1111111111-3333333333 |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT '3333333333-' || string_agg(DISTINCT tab0l0, '|', 100000) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------+
+| col                   |
++-----------------------+
+| 3333333333-1111111111 |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT tab0l0, ',', 100000) || '-' || string_agg(tab0l0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| 1111111111-1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(string_agg(tab0l0, ','), '-', string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| 1111111111,1111111111,1111111111,1111111111,1111111111,1111111111-1111111111 |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(DISTINCT tab0l0, '|', 100000), '-3333333333') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------+
+| col                   |
++-----------------------+
+| 1111111111-3333333333 |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat('3333333333-', string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------+
+| col                   |
++-----------------------+
+| 3333333333-1111111111 |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(tab0l0, ','), string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+| 1111111111,1111111111,1111111111,1111111111,1111111111,11111111111111111111 |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_format('%s-%s', string_agg(DISTINCT tab0l0, ',', 100000), string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| 1111111111-1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(DISTINCT tab0l0, '|', 100000), 16) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------+
+| col         |
++-------------+
+| 73300775185 |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1' IN string_agg(DISTINCT tab0l0, '|', 100000)
+                FROM 2) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(DISTINCT tab0l0, '|', 100000), '110') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(DISTINCT tab0l0, '|', 100000), '210') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT tab0l0, '|', 100000), '110') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT tab0l0, '|', 100000), '210') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT tab0l0, '|', 100000), '1111111111') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT tab0l0, '|', 100000), '2222222222') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT tab0l0, '|', 100000), '1111111111') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT tab0l0, '|', 100000), '2222222222') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(DISTINCT tab0l0, '|', 100000), '1111111111', '3333333333') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 3333333333 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(DISTINCT tab0l0, '|', 100000), '4444444444', '3333333333') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT tab0l0, '|', 100000), '1111111111') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT tab0l0, '|', 100000), '4444444444') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(DISTINCT tab0l0, '|', 100000), 10) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+| 1   |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(DISTINCT tab0l0, '|', 100000), 10, 100) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+| 1   |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH
+            FROM string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING
+            FROM string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING
+            FROM string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH '1'
+            FROM string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING '1'
+            FROM string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING '1'
+            FROM string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(DISTINCT tab0l0, '|', 100000), '1') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(DISTINCT tab0l0, '|', 100000), '1') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(DISTINCT tab0l0, '|', 100000), '1') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(string_agg(DISTINCT tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------+
+| col        |
++------------+
+| 1111111111 |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0l0, '|', 100000), -1) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0l0, '|', 100000), 0) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0l0, '|', 100000), 2) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++----------------------+
+| col                  |
++----------------------+
+| 11111111111111111111 |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A51 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT tab0l0, '|', 100000), 5) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| 11111 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT tab0l0, '|', 100000), 5, '3') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| 11111 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT tab0l0, '|', 100000), 20) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++----------------------+
+| col                  |
++----------------------+
+|           1111111111 |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT tab0l0, '|', 100000), 20, '3') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++----------------------+
+| col                  |
++----------------------+
+| 33333333331111111111 |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT tab0l0, '|', 100000), 5) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| 11111 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT tab0l0, '|', 100000), 5, '3') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| 11111 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT tab0l0, '|', 100000), 20) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++----------------------+
+| col                  |
++----------------------+
+| 1111111111           |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A58 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT tab0l0, '|', 100000), 20, '3') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++----------------------+
+| col                  |
++----------------------+
+| 11111111113333333333 |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A59 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(DISTINCT t0.tab0l0, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0l0 IS NOT NULL);
++-----+
+| LEN |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A60 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(DISTINCT t0.tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0l0 IS NOT NULL;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A61 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(DISTINCT t0.tab0l0, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0l0);
++-----+
+| LEN |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A62 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(DISTINCT t0.tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0l0;
++-----+
+| col |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(1111111111, '|', 100000) AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(tab0l0, '|', 100000) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0l0, '|', 100000) AS col
+FROM test_agg_funcs
+WHERE tab0l0 IS NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0l0, '|', 100000) || '-3333333333' AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111-3333333333 |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT '3333333333-' || string_agg(tab0l0, '|', 100000) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| 3333333333-1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0l0, ',', 100000) || '-' || string_agg(tab0l0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                 |
++-------------------------------------------------------------------------------------------------------------------------------------+
+| 1111111111,1111111111,1111111111,1111111111,1111111111,1111111111-1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(string_agg(tab0l0, ','), '-', string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                 |
++-------------------------------------------------------------------------------------------------------------------------------------+
+| 1111111111,1111111111,1111111111,1111111111,1111111111,1111111111-1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(tab0l0, '|', 100000), '-3333333333') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111-3333333333 |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat('3333333333-', string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| 3333333333-1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(tab0l0, ',', 100000), string_agg(tab0l0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                |
++------------------------------------------------------------------------------------------------------------------------------------+
+| 1111111111,1111111111,1111111111,1111111111,1111111111,11111111111111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_format('%s-%s', string_agg(tab0l0, ','), string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                 |
++-------------------------------------------------------------------------------------------------------------------------------------+
+| 1111111111,1111111111,1111111111,1111111111,1111111111,1111111111-1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(tab0l0, '|', 100000), 16) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('|1' IN string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|  11 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('|1' IN string_agg(tab0l0, '|', 100000)
+                FROM 12) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|  22 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(tab0l0, '|', 100000), '110\|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(tab0l0, '|', 100000), '210\|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(tab0l0, '|', 100000), '110\|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(tab0l0, '|', 100000), '210\|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(tab0l0, '|', 100000), '1111111111|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(tab0l0, '|', 100000), '2222222222|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(tab0l0, '|', 100000), '1111111111|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(tab0l0, '|', 100000), '2222222222|') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(tab0l0, '|', 100000), '1111111111', '3333333333') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 3333333333|3333333333|3333333333|3333333333|3333333333|3333333333 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(tab0l0, '|', 100000), '4444444444', '3333333333') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(tab0l0, '|', 100000), '|1111111111') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|  11 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(tab0l0, '|', 100000), '|4444444444') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(tab0l0, '|', 100000), 12) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++--------------------------------------------------------+
+| col                                                    |
++--------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111 |
++--------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(tab0l0, '|', 100000), 12, 11) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------+
+| col         |
++-------------+
+| 1111111111| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH
+            FROM string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING
+            FROM string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING
+            FROM string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH '1'
+            FROM string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------------------------------+
+| col                                           |
++-----------------------------------------------+
+| |1111111111|1111111111|1111111111|1111111111| |
++-----------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING '1'
+            FROM string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++---------------------------------------------------------+
+| col                                                     |
++---------------------------------------------------------+
+| |1111111111|1111111111|1111111111|1111111111|1111111111 |
++---------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING '1'
+            FROM string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++---------------------------------------------------------+
+| col                                                     |
++---------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111| |
++---------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(tab0l0, '|', 100000), '1') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------------------------------+
+| col                                           |
++-----------------------------------------------+
+| |1111111111|1111111111|1111111111|1111111111| |
++-----------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(tab0l0, '|', 100000), '1') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++---------------------------------------------------------+
+| col                                                     |
++---------------------------------------------------------+
+| |1111111111|1111111111|1111111111|1111111111|1111111111 |
++---------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(tab0l0, '|', 100000), '1') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++---------------------------------------------------------+
+| col                                                     |
++---------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111| |
++---------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(string_agg(tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0l0, '|', 100000), -1) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0l0, '|', 100000), 0) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0l0, '|', 100000), 2) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                |
++------------------------------------------------------------------------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|11111111111111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(tab0l0, '|', 100000), 11) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------+
+| col         |
++-------------+
+| 1111111111| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(tab0l0, '|', 100000), 11, '3') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------+
+| col         |
++-------------+
+| 1111111111| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(tab0l0, '|', 100000), 75) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+|           1111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(tab0l0, '|', 100000), 75, '3') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+| 33333333331111111111|1111111111|1111111111|1111111111|1111111111|1111111111 |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(tab0l0, '|', 100000), 11) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------+
+| col         |
++-------------+
+| 1111111111| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(tab0l0, '|', 100000), 11, '3') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-------------+
+| col         |
++-------------+
+| 1111111111| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(tab0l0, '|', 100000), 75) AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|1111111111           |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A58 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(tab0l0, '|', 100000), 75, '3') AS col
+FROM test_agg_funcs
+WHERE tab0l0=1111111111;
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+| 1111111111|1111111111|1111111111|1111111111|1111111111|11111111113333333333 |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A59 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(t0.tab0l0, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0l0 IS NOT NULL);
++-------+
+| LEN   |
++-------+
+| 42767 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A60 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(t0.tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0l0 IS NOT NULL;
++-------+
+| col   |
++-------+
+| 42767 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A61 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(t0.tab0l0, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0l0);
++-------+
+| LEN   |
++-------+
+| 21383 |
+| 21383 |
+|       |
++-------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A62 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(t0.tab0l0, '|', 100000)) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0l0;
++-------+
+| col   |
++-------+
+| 21383 |
+| 21383 |
+|       |
++-------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 249 Positive tests: 241 Negative tests: 8
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_misc.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_misc.iq
new file mode 100644
index 000000000000..45bafb39f7c9
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_misc.iq
@@ -0,0 +1,859 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaAggFuncs&numMergeBuffers=3
+!set outputformat mysql
+SELECT count(*) cnt
+FROM test_agg_funcs;
++-----+
+| cnt |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(c1) len_c1,
+       strlen(c2) len_c2,
+       strlen(c5) len_c5
+FROM
+  (SELECT string_agg(tab0s0, '|') AS c1,
+          string_agg(tab0l0, '#') AS c2,
+          string_agg(tab0d0, '&') AS c3,
+          string_agg(tab0f0, '*') AS c4,
+          string_agg(__time, '@') AS c5
+   FROM test_agg_funcs);
++--------+--------+--------+
+| len_c1 | len_c2 | len_c5 |
++--------+--------+--------+
+|    131 |    131 |    251 |
++--------+--------+--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A02 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '|'),
+       tab0l0,
+       tab0d0
+FROM test_agg_funcs;
+is not being grouped
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(c1) len_c1
+FROM
+  (SELECT string_agg(tab0s0, '|') AS c1,
+          tab0l0 AS c2,
+          tab0d0 AS c3
+   FROM test_agg_funcs
+   GROUP BY tab0s0,
+            tab0l0,
+            tab0d0);
++--------+
+| len_c1 |
++--------+
+|     21 |
+|     21 |
+|     21 |
+|     21 |
+|     21 |
+|     21 |
+|        |
+|        |
+|        |
++--------+
+(9 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(tab0s0||'001', 100000)) AS c1,
+       length(string_agg(tab0s0||'002', 100000)) AS c2,
+       length(string_agg(tab0s0||'003', 100000)) AS c3,
+       length(string_agg(tab0s0||'004', 100000)) AS c4,
+       length(string_agg(tab0s0||'005', 100000)) AS c5,
+       length(string_agg(tab0s0||'006', 100000)) AS c6,
+       length(string_agg(tab0s0||'007', 100000)) AS c7,
+       length(string_agg(tab0s0||'008', 100000)) AS c8,
+       length(string_agg(tab0s0||'009', 100000)) AS c9,
+       length(string_agg(tab0s0||'010', 100000)) AS c10,
+       length(string_agg(tab0s0||'011', 100000)) AS c11,
+       length(string_agg(tab0s0||'012', 100000)) AS c12,
+       length(string_agg(tab0s0||'013', 100000)) AS c13,
+       length(string_agg(tab0s0||'014', 100000)) AS c14,
+       length(string_agg(tab0s0||'015', 100000)) AS c15,
+       length(string_agg(tab0s0||'016', 100000)) AS c16,
+       length(string_agg(tab0s0||'017', 100000)) AS c17,
+       length(string_agg(tab0s0||'018', 100000)) AS c18,
+       length(string_agg(tab0s0||'019', 100000)) AS c19,
+       length(string_agg(tab0s0||'020', 100000)) AS c20,
+       length(string_agg(tab0s0||'021', 100000)) AS c21,
+       length(string_agg(tab0s0||'022', 100000)) AS c22,
+       length(string_agg(tab0s0||'023', 100000)) AS c23,
+       length(string_agg(tab0s0||'024', 100000)) AS c24,
+       length(string_agg(tab0s0||'025', 100000)) AS c25,
+       length(string_agg(tab0s0||'026', 100000)) AS c26,
+       length(string_agg(tab0s0||'027', 100000)) AS c27,
+       length(string_agg(tab0s0||'028', 100000)) AS c28,
+       length(string_agg(tab0s0||'029', 100000)) AS c29,
+       length(string_agg(tab0s0||'030', 100000)) AS c30,
+       length(string_agg(tab0s0||'031', 100000)) AS c31,
+       length(string_agg(tab0s0||'032', 100000)) AS c32,
+       length(string_agg(tab0s0||'033', 100000)) AS c33,
+       length(string_agg(tab0s0||'034', 100000)) AS c34,
+       length(string_agg(tab0s0||'035', 100000)) AS c35,
+       length(string_agg(tab0s0||'036', 100000)) AS c36,
+       length(string_agg(tab0s0||'037', 100000)) AS c37,
+       length(string_agg(tab0s0||'038', 100000)) AS c38,
+       length(string_agg(tab0s0||'039', 100000)) AS c39,
+       length(string_agg(tab0s0||'040', 100000)) AS c40,
+       length(string_agg(tab0s0||'041', 100000)) AS c41,
+       length(string_agg(tab0s0||'042', 100000)) AS c42,
+       length(string_agg(tab0s0||'043', 100000)) AS c43,
+       length(string_agg(tab0s0||'044', 100000)) AS c44,
+       length(string_agg(tab0s0||'045', 100000)) AS c45,
+       length(string_agg(tab0s0||'046', 100000)) AS c46,
+       length(string_agg(tab0s0||'047', 100000)) AS c47,
+       length(string_agg(tab0s0||'048', 100000)) AS c48,
+       length(string_agg(tab0s0||'049', 100000)) AS c49,
+       length(string_agg(tab0s0||'050', 100000)) AS c50,
+       length(string_agg(tab0s0||'051', 100000)) AS c51,
+       length(string_agg(tab0s0||'052', 100000)) AS c52,
+       length(string_agg(tab0s0||'053', 100000)) AS c53,
+       length(string_agg(tab0s0||'054', 100000)) AS c54,
+       length(string_agg(tab0s0||'055', 100000)) AS c55,
+       length(string_agg(tab0s0||'056', 100000)) AS c56,
+       length(string_agg(tab0s0||'057', 100000)) AS c57,
+       length(string_agg(tab0s0||'058', 100000)) AS c58,
+       length(string_agg(tab0s0||'059', 100000)) AS c59,
+       length(string_agg(tab0s0||'060', 100000)) AS c60,
+       length(string_agg(tab0s0||'061', 100000)) AS c61,
+       length(string_agg(tab0s0||'062', 100000)) AS c62,
+       length(string_agg(tab0s0||'063', 100000)) AS c63,
+       length(string_agg(tab0s0||'064', 100000)) AS c64,
+       length(string_agg(tab0s0||'065', 100000)) AS c65,
+       length(string_agg(tab0s0||'066', 100000)) AS c66,
+       length(string_agg(tab0s0||'067', 100000)) AS c67,
+       length(string_agg(tab0s0||'068', 100000)) AS c68,
+       length(string_agg(tab0s0||'069', 100000)) AS c69,
+       length(string_agg(tab0s0||'070', 100000)) AS c70,
+       length(string_agg(tab0s0||'071', 100000)) AS c71,
+       length(string_agg(tab0s0||'072', 100000)) AS c72,
+       length(string_agg(tab0s0||'073', 100000)) AS c73,
+       length(string_agg(tab0s0||'074', 100000)) AS c74,
+       length(string_agg(tab0s0||'075', 100000)) AS c75,
+       length(string_agg(tab0s0||'076', 100000)) AS c76,
+       length(string_agg(tab0s0||'077', 100000)) AS c77,
+       length(string_agg(tab0s0||'078', 100000)) AS c78,
+       length(string_agg(tab0s0||'079', 100000)) AS c79,
+       length(string_agg(tab0s0||'080', 100000)) AS c80,
+       length(string_agg(tab0s0||'081', 100000)) AS c81,
+       length(string_agg(tab0s0||'082', 100000)) AS c82,
+       length(string_agg(tab0s0||'083', 100000)) AS c83,
+       length(string_agg(tab0s0||'084', 100000)) AS c84,
+       length(string_agg(tab0s0||'085', 100000)) AS c85,
+       length(string_agg(tab0s0||'086', 100000)) AS c86,
+       length(string_agg(tab0s0||'087', 100000)) AS c87,
+       length(string_agg(tab0s0||'088', 100000)) AS c88,
+       length(string_agg(tab0s0||'089', 100000)) AS c89,
+       length(string_agg(tab0s0||'090', 100000)) AS c90,
+       length(string_agg(tab0s0||'091', 100000)) AS c91,
+       length(string_agg(tab0s0||'092', 100000)) AS c92,
+       length(string_agg(tab0s0||'093', 100000)) AS c93,
+       length(string_agg(tab0s0||'094', 100000)) AS c94,
+       length(string_agg(tab0s0||'095', 100000)) AS c95,
+       length(string_agg(tab0s0||'096', 100000)) AS c96,
+       length(string_agg(tab0s0||'097', 100000)) AS c97,
+       length(string_agg(tab0s0||'098', 100000)) AS c98,
+       length(string_agg(tab0s0||'099', 100000)) AS c99,
+       length(string_agg(tab0s0||'100', 100000)) AS c100
+FROM test_agg_funcs
+GROUP BY __time;
++-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+------+
+| c1  | c2  | c3  | c4  | c5  | c6  | c7  | c8  | c9  | c10 | c11 | c12 | c13 | c14 | c15 | c16 | c17 | c18 | c19 | c20 | c21 | c22 | c23 | c24 | c25 | c26 | c27 | c28 | c29 | c30 | c31 | c32 | c33 | c34 | c35 | c36 | c37 | c38 | c39 | c40 | c41 | c42 | c43 | c44 | c45 | c46 | c47 | c48 | c49 | c50 | c51 | c52 | c53 | c54 | c55 | c56 | c57 | c58 | c59 | c60 | c61 | c62 | c63 | c64 | c65 | c66 | c67 | c68 | c69 | c70 | c71 | c72 | c73 | c74 | c75 | c76 | c77 | c78 | c79 | c80 | c81 | c82 | c83 | c84 | c85 | c86 | c87 | c88 | c89 | c90 | c91 | c92 | c93 | c94 | c95 | c96 | c97 | c98 | c99 | c100 |
++-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+------+
+| 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 |  108 |
+| 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 | 108 |  108 |
++-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(lower(tab0s0), '|') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| aaaaaaaaaa|aaaaaaaaaa|aaaaaaaaaa|aaaaaaaaaa|aaaaaaaaaa|aaaaaaaaaa |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0 || tab0s0 || tab0s0 || tab0s0 || tab0s0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                                                                                                                                                                                               |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(length(tab0s0), '|') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------+
+| col               |
++-------------------+
+| 10|10|10|10|10|10 |
++-------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '|', 'Not even a size') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: A02 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '|', -1) AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: A03 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '|', 0) AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: A04 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '|', 1) AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: A05 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '|', 2147483648) AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '|', 2147483647) AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '|', 100000000) AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '|', 10000000) AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(string_agg(tab0s0, '1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890')) AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++--------+
+| col    |
++--------+
+| 500060 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++--------------------------------------------------------------+
+| col                                                          |
++--------------------------------------------------------------+
+| AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |
++--------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '~') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA~AAAAAAAAAA~AAAAAAAAAA~AAAAAAAAAA~AAAAAAAAAA~AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '`') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA`AAAAAAAAAA`AAAAAAAAAA`AAAAAAAAAA`AAAAAAAAAA`AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '!') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA!AAAAAAAAAA!AAAAAAAAAA!AAAAAAAAAA!AAAAAAAAAA!AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '@') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA@AAAAAAAAAA@AAAAAAAAAA@AAAAAAAAAA@AAAAAAAAAA@AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '#') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA#AAAAAAAAAA#AAAAAAAAAA#AAAAAAAAAA#AAAAAAAAAA#AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '$') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA$AAAAAAAAAA$AAAAAAAAAA$AAAAAAAAAA$AAAAAAAAAA$AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '%') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA%AAAAAAAAAA%AAAAAAAAAA%AAAAAAAAAA%AAAAAAAAAA%AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '^') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA^AAAAAAAAAA^AAAAAAAAAA^AAAAAAAAAA^AAAAAAAAAA^AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '&') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA&AAAAAAAAAA&AAAAAAAAAA&AAAAAAAAAA&AAAAAAAAAA&AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '*') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA*AAAAAAAAAA*AAAAAAAAAA*AAAAAAAAAA*AAAAAAAAAA*AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '(') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA(AAAAAAAAAA(AAAAAAAAAA(AAAAAAAAAA(AAAAAAAAAA(AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, ')') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA)AAAAAAAAAA)AAAAAAAAAA)AAAAAAAAAA)AAAAAAAAAA)AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '_') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA_AAAAAAAAAA_AAAAAAAAAA_AAAAAAAAAA_AAAAAAAAAA_AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '-') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA-AAAAAAAAAA-AAAAAAAAAA-AAAAAAAAAA-AAAAAAAAAA-AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '+') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA+AAAAAAAAAA+AAAAAAAAAA+AAAAAAAAAA+AAAAAAAAAA+AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '=') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA=AAAAAAAAAA=AAAAAAAAAA=AAAAAAAAAA=AAAAAAAAAA=AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '{') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA{AAAAAAAAAA{AAAAAAAAAA{AAAAAAAAAA{AAAAAAAAAA{AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '[') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA[AAAAAAAAAA[AAAAAAAAAA[AAAAAAAAAA[AAAAAAAAAA[AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '}') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA}AAAAAAAAAA}AAAAAAAAAA}AAAAAAAAAA}AAAAAAAAAA}AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, ']') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA]AAAAAAAAAA]AAAAAAAAAA]AAAAAAAAAA]AAAAAAAAAA]AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, ':') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA:AAAAAAAAAA:AAAAAAAAAA:AAAAAAAAAA:AAAAAAAAAA:AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, ';') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA;AAAAAAAAAA;AAAAAAAAAA;AAAAAAAAAA;AAAAAAAAAA;AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '<') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA<AAAAAAAAAA<AAAAAAAAAA<AAAAAAAAAA<AAAAAAAAAA<AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, ',') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '>') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA>AAAAAAAAAA>AAAAAAAAAA>AAAAAAAAAA>AAAAAAAAAA>AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '.') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA.AAAAAAAAAA.AAAAAAAAAA.AAAAAAAAAA.AAAAAAAAAA.AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '?') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA?AAAAAAAAAA?AAAAAAAAAA?AAAAAAAAAA?AAAAAAAAAA?AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '/') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA/AAAAAAAAAA/AAAAAAAAAA/AAAAAAAAAA/AAAAAAAAAA/AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, ' ') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '	') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA	AAAAAAAAAA	AAAAAAAAAA	AAAAAAAAAA	AAAAAAAAAA	AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: B32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '
+') AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA
+AAAAAAAAAA
+AAAAAAAAAA
+AAAAAAAAAA
+AAAAAAAAAA
+AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test005 TEST_ID: C01 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, 1234567890) AS col
+FROM test_agg_funcs
+WHERE tab0s0 = 'AAAAAAAAAA';
++----------------------------------------------------------------------------------------------------------------+
+| col                                                                                                            |
++----------------------------------------------------------------------------------------------------------------+
+| AAAAAAAAAA1234567890AAAAAAAAAA1234567890AAAAAAAAAA1234567890AAAAAAAAAA1234567890AAAAAAAAAA1234567890AAAAAAAAAA |
++----------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 51 Positive tests: 45 Negative tests: 6
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_string.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_string.iq
new file mode 100644
index 000000000000..1a5f79c89700
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_string.iq
@@ -0,0 +1,3753 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaAggFuncs&numMergeBuffers=3
+!set outputformat mysql
+SELECT count(*) cnt
+FROM test_agg_funcs;
++-----+
+| cnt |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg('AAAAAAAAAA', '|') AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(tab0s0, '|') AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0s0 IS NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '|') || '-CCCCCCCCCC' AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA-CCCCCCCCCC |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT 'CCCCCCCCCC-' || string_agg(tab0s0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| CCCCCCCCCC-AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, ',') || '-' || string_agg(tab0s0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                 |
++-------------------------------------------------------------------------------------------------------------------------------------+
+| AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA-AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(string_agg(tab0s0, ','), '-', string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                 |
++-------------------------------------------------------------------------------------------------------------------------------------+
+| AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA-AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(tab0s0, '|'), '-CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA-CCCCCCCCCC |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat('CCCCCCCCCC-', string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| CCCCCCCCCC-AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(tab0s0, ','), string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                |
++------------------------------------------------------------------------------------------------------------------------------------+
+| AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAAAAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_format('%s-%s', string_agg(tab0s0, ','), string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                 |
++-------------------------------------------------------------------------------------------------------------------------------------+
+| AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA-AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| aaaaaaaaaa|aaaaaaaaaa|aaaaaaaaaa|aaaaaaaaaa|aaaaaaaaaa|aaaaaaaaaa |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(tab0s0, '|'), 16) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('|A' IN string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|  11 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('|A' IN string_agg(tab0s0, '|')
+                FROM 12) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|  22 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(tab0s0, '|'), 'A10\|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(tab0s0, '|'), 'B10\|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(tab0s0, '|'), 'A10\|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(tab0s0, '|'), 'B10\|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(tab0s0, '|'), 'AAAAAAAAAA|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(tab0s0, '|'), 'aaaaaaaaaa|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(tab0s0, '|'), 'aaaaaaaaaa|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(tab0s0, '|'), 'BBBBBBBBBB|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(tab0s0, '|'), 'AAAAAAAAAA', 'CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| CCCCCCCCCC|CCCCCCCCCC|CCCCCCCCCC|CCCCCCCCCC|CCCCCCCCCC|CCCCCCCCCC |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(tab0s0, '|'), 'aaaaaaaaaa', 'CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(tab0s0, '|'), '|AAAAAAAAAA') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|  11 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(tab0s0, '|'), '|aaaaaaaaaa') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(tab0s0, '|'), 12) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++--------------------------------------------------------+
+| col                                                    |
++--------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++--------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(tab0s0, '|'), 12, 11) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------+
+| col         |
++-------------+
+| AAAAAAAAAA| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH
+            FROM string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING
+            FROM string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING
+            FROM string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH 'A'
+            FROM string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------------------------------+
+| col                                           |
++-----------------------------------------------+
+| |AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA| |
++-----------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING 'A'
+            FROM string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++---------------------------------------------------------+
+| col                                                     |
++---------------------------------------------------------+
+| |AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++---------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING 'A'
+            FROM string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++---------------------------------------------------------+
+| col                                                     |
++---------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA| |
++---------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(tab0s0, '|'), 'A') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------------------------------+
+| col                                           |
++-----------------------------------------------+
+| |AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA| |
++-----------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(tab0s0, '|'), 'A') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++---------------------------------------------------------+
+| col                                                     |
++---------------------------------------------------------+
+| |AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++---------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(tab0s0, '|'), 'A') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++---------------------------------------------------------+
+| col                                                     |
++---------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA| |
++---------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0s0, '|'), -1) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0s0, '|'), 0) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0s0, '|'), 2) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                |
++------------------------------------------------------------------------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAAAAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A51 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(tab0s0, '|'), 11) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------+
+| col         |
++-------------+
+| AAAAAAAAAA| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(tab0s0, '|'), 11, 'C') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------+
+| col         |
++-------------+
+| AAAAAAAAAA| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(tab0s0, '|'), 75) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+|           AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(tab0s0, '|'), 75, 'C') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+| CCCCCCCCCCAAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(tab0s0, '|'), 11) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------+
+| col         |
++-------------+
+| AAAAAAAAAA| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(tab0s0, '|'), 11, 'C') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------+
+| col         |
++-------------+
+| AAAAAAAAAA| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(tab0s0, '|'), 75) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA           |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A58 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(tab0s0, '|'), 75, 'C') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAACCCCCCCCCC |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A59 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(t0.tab0s0, '|') AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0s0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A60 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(t0.tab0s0, '|')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0s0 IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A61 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(t0.tab0s0, '|') AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0s0;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A62 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(t0.tab0s0, '|')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0s0;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT 'AAAAAAAAAA', '|') AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(DISTINCT tab0s0, '|') AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0s0 IS NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT tab0s0, '|') || '-CCCCCCCCCC' AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------+
+| col                   |
++-----------------------+
+| AAAAAAAAAA-CCCCCCCCCC |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT 'CCCCCCCCCC-' || string_agg(DISTINCT tab0s0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------+
+| col                   |
++-----------------------+
+| CCCCCCCCCC-AAAAAAAAAA |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT tab0s0, ',') || '-' || string_agg(tab0s0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| AAAAAAAAAA-AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(string_agg(tab0s0, ','), '-', string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA-AAAAAAAAAA |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(DISTINCT tab0s0, '|'), '-CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------+
+| col                   |
++-----------------------+
+| AAAAAAAAAA-CCCCCCCCCC |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat('CCCCCCCCCC-', string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------+
+| col                   |
++-----------------------+
+| CCCCCCCCCC-AAAAAAAAAA |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(tab0s0, ','), string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+| AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAAAAAAAAAAAA |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_format('%s-%s', string_agg(DISTINCT tab0s0, ','), string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| AAAAAAAAAA-AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| aaaaaaaaaa |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(DISTINCT tab0s0, '|'), 16) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++--------------+
+| col          |
++--------------+
+| 733007751850 |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('A' IN string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('A' IN string_agg(DISTINCT tab0s0, '|')
+                FROM 2) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(DISTINCT tab0s0, '|'), 'A10') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(DISTINCT tab0s0, '|'), 'B10') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT tab0s0, '|'), 'A10') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT tab0s0, '|'), 'B10') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT tab0s0, '|'), 'AAAAAAAAAA') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT tab0s0, '|'), 'aaaaaaaaaa') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT tab0s0, '|'), 'aaaaaaaaaa') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT tab0s0, '|'), 'BBBBBBBBBB') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(DISTINCT tab0s0, '|'), 'AAAAAAAAAA', 'CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| CCCCCCCCCC |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(DISTINCT tab0s0, '|'), 'aaaaaaaaaa', 'CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT tab0s0, '|'), 'AAAAAAAAAA') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT tab0s0, '|'), 'aaaaaaaaaa') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(DISTINCT tab0s0, '|'), 10) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+| A   |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(DISTINCT tab0s0, '|'), 10, 100) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+| A   |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH
+            FROM string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING
+            FROM string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING
+            FROM string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH 'A'
+            FROM string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING 'A'
+            FROM string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING 'A'
+            FROM string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(DISTINCT tab0s0, '|'), 'A') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(DISTINCT tab0s0, '|'), 'A') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(DISTINCT tab0s0, '|'), 'A') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(string_agg(DISTINCT tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0s0, '|'), -1) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0s0, '|'), 0) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0s0, '|'), 2) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++----------------------+
+| col                  |
++----------------------+
+| AAAAAAAAAAAAAAAAAAAA |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A51 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT tab0s0, '|'), 5) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| AAAAA |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT tab0s0, '|'), 5, 'C') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| AAAAA |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT tab0s0, '|'), 20) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++----------------------+
+| col                  |
++----------------------+
+|           AAAAAAAAAA |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT tab0s0, '|'), 20, 'C') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++----------------------+
+| col                  |
++----------------------+
+| CCCCCCCCCCAAAAAAAAAA |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT tab0s0, '|'), 5) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| AAAAA |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT tab0s0, '|'), 5, 'C') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| AAAAA |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT tab0s0, '|'), 20) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++----------------------+
+| col                  |
++----------------------+
+| AAAAAAAAAA           |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A58 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT tab0s0, '|'), 20, 'C') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++----------------------+
+| col                  |
++----------------------+
+| AAAAAAAAAACCCCCCCCCC |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A59 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(DISTINCT t0.tab0s0, '|') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0s0 IS NOT NULL);
++-----+
+| LEN |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A60 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(DISTINCT t0.tab0s0, '|')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0s0 IS NOT NULL;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A61 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(DISTINCT t0.tab0s0, '|') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0s0);
++-----+
+| LEN |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A62 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(DISTINCT t0.tab0s0, '|')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0s0;
++-----+
+| col |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT 'AAAAAAAAAA', '|', 100000) AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(DISTINCT tab0s0, '|', 100000) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '|', 100000) AS col
+FROM test_agg_funcs
+WHERE tab0s0 IS NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT tab0s0, '|', 100000) || '-CCCCCCCCCC' AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------+
+| col                   |
++-----------------------+
+| AAAAAAAAAA-CCCCCCCCCC |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT 'CCCCCCCCCC-' || string_agg(DISTINCT tab0s0, '|', 100000) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------+
+| col                   |
++-----------------------+
+| CCCCCCCCCC-AAAAAAAAAA |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT tab0s0, ',', 100000) || '-' || string_agg(tab0s0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| AAAAAAAAAA-AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(string_agg(tab0s0, ','), '-', string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA-AAAAAAAAAA |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(DISTINCT tab0s0, '|', 100000), '-CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------+
+| col                   |
++-----------------------+
+| AAAAAAAAAA-CCCCCCCCCC |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat('CCCCCCCCCC-', string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------+
+| col                   |
++-----------------------+
+| CCCCCCCCCC-AAAAAAAAAA |
++-----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(tab0s0, ','), string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+| AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAAAAAAAAAAAA |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_format('%s-%s', string_agg(DISTINCT tab0s0, ',', 100000), string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| AAAAAAAAAA-AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| aaaaaaaaaa |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(DISTINCT tab0s0, '|', 100000), 16) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++--------------+
+| col          |
++--------------+
+| 733007751850 |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('A' IN string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('A' IN string_agg(DISTINCT tab0s0, '|', 100000)
+                FROM 2) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(DISTINCT tab0s0, '|', 100000), 'A10') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(DISTINCT tab0s0, '|', 100000), 'B10') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT tab0s0, '|', 100000), 'A10') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT tab0s0, '|', 100000), 'B10') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT tab0s0, '|', 100000), 'AAAAAAAAAA') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT tab0s0, '|', 100000), 'aaaaaaaaaa') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT tab0s0, '|', 100000), 'aaaaaaaaaa') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT tab0s0, '|', 100000), 'BBBBBBBBBB') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(DISTINCT tab0s0, '|', 100000), 'AAAAAAAAAA', 'CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| CCCCCCCCCC |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(DISTINCT tab0s0, '|', 100000), 'aaaaaaaaaa', 'CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT tab0s0, '|', 100000), 'AAAAAAAAAA') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT tab0s0, '|', 100000), 'aaaaaaaaaa') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(DISTINCT tab0s0, '|', 100000), 10) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+| A   |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(DISTINCT tab0s0, '|', 100000), 10, 100) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+| A   |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH
+            FROM string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING
+            FROM string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING
+            FROM string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH 'A'
+            FROM string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING 'A'
+            FROM string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING 'A'
+            FROM string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(DISTINCT tab0s0, '|', 100000), 'A') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(DISTINCT tab0s0, '|', 100000), 'A') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(DISTINCT tab0s0, '|', 100000), 'A') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(string_agg(DISTINCT tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------+
+| col        |
++------------+
+| AAAAAAAAAA |
++------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0s0, '|', 100000), -1) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0s0, '|', 100000), 0) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT tab0s0, '|', 100000), 2) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++----------------------+
+| col                  |
++----------------------+
+| AAAAAAAAAAAAAAAAAAAA |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A51 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT tab0s0, '|', 100000), 5) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| AAAAA |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT tab0s0, '|', 100000), 5, 'C') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| AAAAA |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT tab0s0, '|', 100000), 20) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++----------------------+
+| col                  |
++----------------------+
+|           AAAAAAAAAA |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT tab0s0, '|', 100000), 20, 'C') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++----------------------+
+| col                  |
++----------------------+
+| CCCCCCCCCCAAAAAAAAAA |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT tab0s0, '|', 100000), 5) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| AAAAA |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT tab0s0, '|', 100000), 5, 'C') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| AAAAA |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT tab0s0, '|', 100000), 20) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++----------------------+
+| col                  |
++----------------------+
+| AAAAAAAAAA           |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A58 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT tab0s0, '|', 100000), 20, 'C') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++----------------------+
+| col                  |
++----------------------+
+| AAAAAAAAAACCCCCCCCCC |
++----------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A59 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(DISTINCT t0.tab0s0, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0s0 IS NOT NULL);
++-----+
+| LEN |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A60 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(DISTINCT t0.tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0s0 IS NOT NULL;
++-----+
+| col |
++-----+
+|  21 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A61 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(DISTINCT t0.tab0s0, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0s0);
++-----+
+| LEN |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A62 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(DISTINCT t0.tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0s0;
++-----+
+| col |
++-----+
+|  10 |
+|  10 |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg('AAAAAAAAAA', '|', 100000) AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(tab0s0, '|', 100000) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '|', 100000) AS col
+FROM test_agg_funcs
+WHERE tab0s0 IS NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, '|', 100000) || '-CCCCCCCCCC' AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA-CCCCCCCCCC |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT 'CCCCCCCCCC-' || string_agg(tab0s0, '|', 100000) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| CCCCCCCCCC-AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(tab0s0, ',', 100000) || '-' || string_agg(tab0s0, '|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                 |
++-------------------------------------------------------------------------------------------------------------------------------------+
+| AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA-AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(string_agg(tab0s0, ','), '-', string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                 |
++-------------------------------------------------------------------------------------------------------------------------------------+
+| AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA-AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(tab0s0, '|', 100000), '-CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA-CCCCCCCCCC |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat('CCCCCCCCCC-', string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------------------------------------------------------------------------+
+| col                                                                          |
++------------------------------------------------------------------------------+
+| CCCCCCCCCC-AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(tab0s0, ',', 100000), string_agg(tab0s0, '|')) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                |
++------------------------------------------------------------------------------------------------------------------------------------+
+| AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAAAAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_format('%s-%s', string_agg(tab0s0, ','), string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                 |
++-------------------------------------------------------------------------------------------------------------------------------------+
+| AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA,AAAAAAAAAA-AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 131 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| aaaaaaaaaa|aaaaaaaaaa|aaaaaaaaaa|aaaaaaaaaa|aaaaaaaaaa|aaaaaaaaaa |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(tab0s0, '|', 100000), 16) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('|A' IN string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|  11 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('|A' IN string_agg(tab0s0, '|', 100000)
+                FROM 12) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|  22 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(tab0s0, '|', 100000), 'A10\|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(tab0s0, '|', 100000), 'B10\|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(tab0s0, '|', 100000), 'A10\|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(tab0s0, '|', 100000), 'B10\|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(tab0s0, '|', 100000), 'AAAAAAAAAA|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(tab0s0, '|', 100000), 'aaaaaaaaaa|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(tab0s0, '|', 100000), 'aaaaaaaaaa|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(tab0s0, '|', 100000), 'BBBBBBBBBB|') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(tab0s0, '|', 100000), 'AAAAAAAAAA', 'CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| CCCCCCCCCC|CCCCCCCCCC|CCCCCCCCCC|CCCCCCCCCC|CCCCCCCCCC|CCCCCCCCCC |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(tab0s0, '|', 100000), 'aaaaaaaaaa', 'CCCCCCCCCC') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(tab0s0, '|', 100000), '|AAAAAAAAAA') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|  11 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(tab0s0, '|', 100000), '|aaaaaaaaaa') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(tab0s0, '|', 100000), 12) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++--------------------------------------------------------+
+| col                                                    |
++--------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++--------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(tab0s0, '|', 100000), 12, 11) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------+
+| col         |
++-------------+
+| AAAAAAAAAA| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH
+            FROM string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING
+            FROM string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING
+            FROM string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH 'A'
+            FROM string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------------------------------+
+| col                                           |
++-----------------------------------------------+
+| |AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA| |
++-----------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING 'A'
+            FROM string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++---------------------------------------------------------+
+| col                                                     |
++---------------------------------------------------------+
+| |AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++---------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING 'A'
+            FROM string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++---------------------------------------------------------+
+| col                                                     |
++---------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA| |
++---------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(tab0s0, '|', 100000), 'A') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------------------------------+
+| col                                           |
++-----------------------------------------------+
+| |AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA| |
++-----------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(tab0s0, '|', 100000), 'A') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++---------------------------------------------------------+
+| col                                                     |
++---------------------------------------------------------+
+| |AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++---------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(tab0s0, '|', 100000), 'A') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++---------------------------------------------------------+
+| col                                                     |
++---------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA| |
++---------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(string_agg(tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------------------------------------------------------------+
+| col                                                               |
++-------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0s0, '|', 100000), -1) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0s0, '|', 100000), 0) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(tab0s0, '|', 100000), 2) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                |
++------------------------------------------------------------------------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAAAAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A51 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(tab0s0, '|', 100000), 11) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------+
+| col         |
++-------------+
+| AAAAAAAAAA| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(tab0s0, '|', 100000), 11, 'C') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------+
+| col         |
++-------------+
+| AAAAAAAAAA| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(tab0s0, '|', 100000), 75) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+|           AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(tab0s0, '|', 100000), 75, 'C') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+| CCCCCCCCCCAAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(tab0s0, '|', 100000), 11) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------+
+| col         |
++-------------+
+| AAAAAAAAAA| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(tab0s0, '|', 100000), 11, 'C') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-------------+
+| col         |
++-------------+
+| AAAAAAAAAA| |
++-------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(tab0s0, '|', 100000), 75) AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA           |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A58 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(tab0s0, '|', 100000), 75, 'C') AS col
+FROM test_agg_funcs
+WHERE tab0s0='AAAAAAAAAA';
++-----------------------------------------------------------------------------+
+| col                                                                         |
++-----------------------------------------------------------------------------+
+| AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAA|AAAAAAAAAACCCCCCCCCC |
++-----------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A59 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(t0.tab0s0, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.tab0s0 IS NOT NULL);
++-------+
+| LEN   |
++-------+
+| 42767 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A60 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(t0.tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.tab0s0 IS NOT NULL;
++-------+
+| col   |
++-------+
+| 42767 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A61 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(t0.tab0s0, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.tab0s0);
++-------+
+| LEN   |
++-------+
+| 21383 |
+| 21383 |
+|       |
++-------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A62 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(t0.tab0s0, '|', 100000)) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.tab0s0;
++-------+
+| col   |
++-------+
+| 21383 |
+| 21383 |
+|       |
++-------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 249 Positive tests: 241 Negative tests: 8
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_timestamp.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_timestamp.iq
new file mode 100644
index 000000000000..81457e9a5827
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaAggFuncs_string_agg_timestamp.iq
@@ -0,0 +1,3675 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaAggFuncs&numMergeBuffers=3
+!set outputformat mysql
+SELECT count(*) cnt
+FROM test_agg_funcs;
++-----+
+| cnt |
++-----+
+|  18 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(timestamp '2020-01-01 01:01:01.000', '|') AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(__time, '|') AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 251 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(__time, '|') || '-1583024461000' AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                         |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000-1583024461000 |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT '1583024461000-' || string_agg(__time, '|') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                         |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| 1583024461000-1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(__time, ',') || '-' || string_agg(__time, '|') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                                                                                                                                         |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000-1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(string_agg(__time, ','), '-', string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                                                                                                                                         |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000-1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(__time, '|'), '-1583024461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                         |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000-1583024461000 |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat('1583024461000-', string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                         |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| 1583024461000-1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(__time, ','), string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                                                                                                                                        |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,15778404610001577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_format('%s-%s', string_agg(__time, ','), string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                                                                                                                                         |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000-1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(__time, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 251 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(string_agg(__time, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 251 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(__time, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 251 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(__time, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 251 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(__time, '|'), 16) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1577840461000' IN string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1577840461000' IN string_agg(__time, '|')
+                FROM 20) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|  29 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(__time, '|'), '15778404610001') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(__time, '|'), '15778404610002') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(__time, '|'), '15778404610001') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(__time, '|'), '15778404610002') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(__time, '|'), '1577840461000|') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(__time, '|'), '1580518861000|') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(__time, '|'), '1577840461000|') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(__time, '|'), '1580518861000|') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(__time, '|'), '1577840461000', '1583024461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1583024461000|1583024461000|1583024461000|1583024461000|1583024461000|1583024461000|1583024461000|1583024461000|1583024461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(__time, '|'), '4444444444', '1583024461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(__time, '|'), '|1577840461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|  14 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(__time, '|'), '|4444444444') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(__time, '|'), 15) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------------------------------------------------------------------------------------------+
+| col                                                                                                             |
++-----------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-----------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(__time, '|'), 15, 14) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++----------------+
+| col            |
++----------------+
+| 1577840461000| |
++----------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH
+            FROM string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING
+            FROM string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING
+            FROM string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH '1234567890'
+            FROM string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------------------------------------------------------------------------------+
+| col                                                                                                 |
++-----------------------------------------------------------------------------------------------------+
+| |1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000| |
++-----------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING '1234567890'
+            FROM string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                              |
++------------------------------------------------------------------------------------------------------------------+
+| |1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING '1234567890'
+            FROM string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                              |
++------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000| |
++------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(__time, '|'), '1234567890') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------------------------------------------------------------------------------+
+| col                                                                                                 |
++-----------------------------------------------------------------------------------------------------+
+| |1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000| |
++-----------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(__time, '|'), '1234567890') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                              |
++------------------------------------------------------------------------------------------------------------------+
+| |1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(__time, '|'), '1234567890') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                              |
++------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000| |
++------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 0001640487751|0001640487751|0001640487751|0001640487751|0001640487751|0001640487751|0001640487751|0001640487751|0001640487751 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(__time, '|'), -1) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(__time, '|'), 0) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(__time, '|'), 2) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                                                                                                                                        |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|15778404610001577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(__time, '|'), 14) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++----------------+
+| col            |
++----------------+
+| 1577840461000| |
++----------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A51 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(__time, '|'), 14, 'A') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++----------------+
+| col            |
++----------------+
+| 1577840461000| |
++----------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(__time, '|'), 135) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                     |
++-----------------------------------------------------------------------------------------------------------------------------------------+
+|           1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-----------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(__time, '|'), 135, 'A') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                     |
++-----------------------------------------------------------------------------------------------------------------------------------------+
+| AAAAAAAAAA1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-----------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(__time, '|'), 14) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++----------------+
+| col            |
++----------------+
+| 1577840461000| |
++----------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(__time, '|'), 14, 'A') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++----------------+
+| col            |
++----------------+
+| 1577840461000| |
++----------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(__time, '|'), 135) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                     |
++-----------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000           |
++-----------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(__time, '|'), 135, 'A') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                     |
++-----------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000AAAAAAAAAA |
++-----------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A58 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(t0.__time, '|') AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.__time IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A59 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(t0.__time, '|')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.__time IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A60 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(t0.__time, '|') AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.__time;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test001 TEST_ID: A61 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(t0.__time, '|')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.__time;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT timestamp '2020-01-01 01:01:01.000', '|') AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(DISTINCT __time, '|') AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT __time, '|') || '-1583024461000' AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------+
+| col                         |
++-----------------------------+
+| 1577840461000-1583024461000 |
++-----------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT '1583024461000-' || string_agg(DISTINCT __time, '|') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------+
+| col                         |
++-----------------------------+
+| 1583024461000-1577840461000 |
++-----------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT __time, ',') || '-' || string_agg(__time, '|') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                         |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000-1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(string_agg(__time, ','), '-', string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                         |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000-1577840461000 |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(DISTINCT __time, '|'), '-1583024461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------+
+| col                         |
++-----------------------------+
+| 1577840461000-1583024461000 |
++-----------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat('1583024461000-', string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------+
+| col                         |
++-----------------------------+
+| 1583024461000-1577840461000 |
++-----------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(__time, ','), string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++--------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                        |
++--------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,15778404610001577840461000 |
++--------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_format('%s-%s', string_agg(DISTINCT __time, ','), string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                         |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000-1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1577840461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(DISTINCT __time, '|'), 16) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------+
+| col             |
++-----------------+
+| 377648962736128 |
++-----------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1577840461000' IN string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1577840461000' IN string_agg(DISTINCT __time, '|')
+                FROM 15) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(DISTINCT __time, '|'), '15778404610001') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(DISTINCT __time, '|'), '15778404610002') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT __time, '|'), '15778404610001') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT __time, '|'), '15778404610002') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT __time, '|'), '1577840461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT __time, '|'), '1580518861000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT __time, '|'), '1577840461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT __time, '|'), '1580518861000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(DISTINCT __time, '|'), '1577840461000', '1583024461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1583024461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(DISTINCT __time, '|'), '4444444444', '1583024461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1577840461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT __time, '|'), '1577840461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT __time, '|'), '4444444444') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(DISTINCT __time, '|'), 13) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+| 0   |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(DISTINCT __time, '|'), 13, 100) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+| 0   |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH
+            FROM string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1577840461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING
+            FROM string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1577840461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING
+            FROM string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1577840461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH '1234567890'
+            FROM string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING '1234567890'
+            FROM string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING '1234567890'
+            FROM string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1577840461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(DISTINCT __time, '|'), '1234567890') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1577840461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(DISTINCT __time, '|'), '1234567890') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1577840461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(DISTINCT __time, '|'), '1234567890') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1577840461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(string_agg(DISTINCT __time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 0001640487751 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT __time, '|'), -1) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT __time, '|'), 0) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT __time, '|'), 2) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++----------------------------+
+| col                        |
++----------------------------+
+| 15778404610001577840461000 |
++----------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT __time, '|'), 5) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| 15778 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A51 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT __time, '|'), 5, 'A') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| 15778 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT __time, '|'), 23) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------+
+| col                     |
++-------------------------+
+|           1577840461000 |
++-------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT __time, '|'), 23, 'A') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------+
+| col                     |
++-------------------------+
+| AAAAAAAAAA1577840461000 |
++-------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT __time, '|'), 5) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| 15778 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT __time, '|'), 5, 'A') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| 15778 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT __time, '|'), 23) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------+
+| col                     |
++-------------------------+
+| 1577840461000           |
++-------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT __time, '|'), 23, 'A') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------+
+| col                     |
++-------------------------+
+| 1577840461000AAAAAAAAAA |
++-------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A58 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(DISTINCT t0.__time, '|') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.__time IS NOT NULL);
++-----+
+| LEN |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A59 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(DISTINCT t0.__time, '|')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.__time IS NOT NULL;
++-----+
+| col |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A60 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(DISTINCT t0.__time, '|') AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.__time);
++-----+
+| LEN |
++-----+
+|  13 |
+|  13 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test002 TEST_ID: A61 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(DISTINCT t0.__time, '|')) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.__time;
++-----+
+| col |
++-----+
+|  13 |
+|  13 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT timestamp '2020-01-01 01:01:01.000', '|', 100000) AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(DISTINCT __time, '|', 100000) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT __time, '|', 100000) || '-1583024461000' AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------+
+| col                         |
++-----------------------------+
+| 1577840461000-1583024461000 |
++-----------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT '1583024461000-' || string_agg(DISTINCT __time, '|', 100000) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------+
+| col                         |
++-----------------------------+
+| 1583024461000-1577840461000 |
++-----------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(DISTINCT __time, ',', 100000) || '-' || string_agg(__time, '|') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                         |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000-1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(string_agg(__time, ','), '-', string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                         |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000-1577840461000 |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(DISTINCT __time, '|', 100000), '-1583024461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------+
+| col                         |
++-----------------------------+
+| 1577840461000-1583024461000 |
++-----------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat('1583024461000-', string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------+
+| col                         |
++-----------------------------+
+| 1583024461000-1577840461000 |
++-----------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(__time, ','), string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++--------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                        |
++--------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,15778404610001577840461000 |
++--------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_format('%s-%s', string_agg(DISTINCT __time, ',', 100000), string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                         |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000-1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1577840461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(DISTINCT __time, '|', 100000), 16) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------+
+| col             |
++-----------------+
+| 377648962736128 |
++-----------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1577840461000' IN string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1577840461000' IN string_agg(DISTINCT __time, '|', 100000)
+                FROM 15) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(DISTINCT __time, '|', 100000), '15778404610001') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(DISTINCT __time, '|', 100000), '15778404610002') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT __time, '|', 100000), '15778404610001') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(DISTINCT __time, '|', 100000), '15778404610002') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT __time, '|', 100000), '1577840461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(DISTINCT __time, '|', 100000), '1580518861000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT __time, '|', 100000), '1577840461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(DISTINCT __time, '|', 100000), '1580518861000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(DISTINCT __time, '|', 100000), '1577840461000', '1583024461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1583024461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(DISTINCT __time, '|', 100000), '4444444444', '1583024461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1577840461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT __time, '|', 100000), '1577840461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(DISTINCT __time, '|', 100000), '4444444444') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(DISTINCT __time, '|', 100000), 13) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+| 0   |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(DISTINCT __time, '|', 100000), 13, 100) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+| 0   |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH
+            FROM string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1577840461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING
+            FROM string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1577840461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING
+            FROM string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1577840461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH '1234567890'
+            FROM string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING '1234567890'
+            FROM string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING '1234567890'
+            FROM string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1577840461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(DISTINCT __time, '|', 100000), '1234567890') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1577840461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(DISTINCT __time, '|', 100000), '1234567890') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1577840461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(DISTINCT __time, '|', 100000), '1234567890') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 1577840461000 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(string_agg(DISTINCT __time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------+
+| col           |
++---------------+
+| 0001640487751 |
++---------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT __time, '|', 100000), -1) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT __time, '|', 100000), 0) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(DISTINCT __time, '|', 100000), 2) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++----------------------------+
+| col                        |
++----------------------------+
+| 15778404610001577840461000 |
++----------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT __time, '|', 100000), 5) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| 15778 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A51 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT __time, '|', 100000), 5, 'A') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| 15778 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT __time, '|', 100000), 23) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------+
+| col                     |
++-------------------------+
+|           1577840461000 |
++-------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(DISTINCT __time, '|', 100000), 23, 'A') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------+
+| col                     |
++-------------------------+
+| AAAAAAAAAA1577840461000 |
++-------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT __time, '|', 100000), 5) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| 15778 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT __time, '|', 100000), 5, 'A') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| 15778 |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT __time, '|', 100000), 23) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------+
+| col                     |
++-------------------------+
+| 1577840461000           |
++-------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(DISTINCT __time, '|', 100000), 23, 'A') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------+
+| col                     |
++-------------------------+
+| 1577840461000AAAAAAAAAA |
++-------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A58 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(DISTINCT t0.__time, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.__time IS NOT NULL);
++-----+
+| LEN |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A59 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(DISTINCT t0.__time, '|', 100000)) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.__time IS NOT NULL;
++-----+
+| col |
++-----+
+|  27 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A60 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(DISTINCT t0.__time, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.__time);
++-----+
+| LEN |
++-----+
+|  13 |
+|  13 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test003 TEST_ID: A61 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(DISTINCT t0.__time, '|', 100000)) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.__time;
++-----+
+| col |
++-----+
+|  13 |
+|  13 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A01 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(timestamp '2020-01-01 01:01:01.000', '|', 100000) AS col;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A02 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(__time, '|', 100000) AS col
+   FROM test_agg_funcs);
++-----+
+| LEN |
++-----+
+| 251 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A03 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(__time, '|', 100000) || '-1583024461000' AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                         |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000-1583024461000 |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A04 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT '1583024461000-' || string_agg(__time, '|', 100000) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                         |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| 1583024461000-1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A05 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_agg(__time, ',', 100000) || '-' || string_agg(__time, '|') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                                                                                                                                         |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000-1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A06 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(string_agg(__time, ','), '-', string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                                                                                                                                         |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000-1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A07 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(__time, '|', 100000), '-1583024461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                         |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000-1583024461000 |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A08 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat('1583024461000-', string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                         |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+| 1583024461000-1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++---------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A09 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(string_agg(__time, ',', 100000), string_agg(__time, '|')) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                                                                                                                                        |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,15778404610001577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_format('%s-%s', string_agg(__time, ','), string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                                                                                                                                         |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000,1577840461000-1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 251 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A12 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 251 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A13 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 251 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A14 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs;
++-----+
+| col |
++-----+
+| 251 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A15 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A16 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(string_agg(__time, '|', 100000), 16) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A17 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1577840461000' IN string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A18 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('1577840461000' IN string_agg(__time, '|', 100000)
+                FROM 20) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|  29 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A19 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(__time, '|', 100000), '15778404610001') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A20 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(string_agg(__time, '|', 100000), '15778404610002') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A21 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(__time, '|', 100000), '15778404610001') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A22 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(string_agg(__time, '|', 100000), '15778404610002') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A23 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(__time, '|', 100000), '1577840461000|') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A24 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(string_agg(__time, '|', 100000), '1580518861000|') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A25 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(__time, '|', 100000), '1577840461000|') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------+
+| col  |
++------+
+| true |
++------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A26 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(string_agg(__time, '|', 100000), '1580518861000|') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------+
+| col   |
++-------+
+| false |
++-------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A27 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(__time, '|', 100000), '1577840461000', '1583024461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1583024461000|1583024461000|1583024461000|1583024461000|1583024461000|1583024461000|1583024461000|1583024461000|1583024461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A28 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(string_agg(__time, '|', 100000), '4444444444', '1583024461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A29 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(__time, '|', 100000), '|1577840461000') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|  14 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A30 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(string_agg(__time, '|', 100000), '|4444444444') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A31 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(__time, '|', 100000), 15) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------------------------------------------------------------------------------------------+
+| col                                                                                                             |
++-----------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-----------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A32 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(string_agg(__time, '|', 100000), 15, 14) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++----------------+
+| col            |
++----------------+
+| 1577840461000| |
++----------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A33 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH
+            FROM string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A34 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING
+            FROM string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A35 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING
+            FROM string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A36 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(BOTH '1234567890'
+            FROM string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------------------------------------------------------------------------------+
+| col                                                                                                 |
++-----------------------------------------------------------------------------------------------------+
+| |1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000| |
++-----------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A37 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(LEADING '1234567890'
+            FROM string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                              |
++------------------------------------------------------------------------------------------------------------------+
+| |1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A38 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(TRAILING '1234567890'
+            FROM string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                              |
++------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000| |
++------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A39 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A40 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(string_agg(__time, '|', 100000), '1234567890') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------------------------------------------------------------------------------+
+| col                                                                                                 |
++-----------------------------------------------------------------------------------------------------+
+| |1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000| |
++-----------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A41 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A42 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(string_agg(__time, '|', 100000), '1234567890') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                              |
++------------------------------------------------------------------------------------------------------------------+
+| |1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A43 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A44 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(string_agg(__time, '|', 100000), '1234567890') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                              |
++------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000| |
++------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A45 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A46 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(string_agg(__time, '|', 100000)) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------+
+| 0001640487751|0001640487751|0001640487751|0001640487751|0001640487751|0001640487751|0001640487751|0001640487751|0001640487751 |
++-------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A47 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(__time, '|', 100000), -1) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A48 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(__time, '|', 100000), 0) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A49 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(string_agg(__time, '|', 100000), 2) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                                                                                                                                        |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|15778404610001577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A50 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(__time, '|', 100000), 14) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++----------------+
+| col            |
++----------------+
+| 1577840461000| |
++----------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A51 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(__time, '|', 100000), 14, 'A') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++----------------+
+| col            |
++----------------+
+| 1577840461000| |
++----------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A52 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(__time, '|', 100000), 135) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                     |
++-----------------------------------------------------------------------------------------------------------------------------------------+
+|           1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-----------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A53 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(string_agg(__time, '|', 100000), 135, 'A') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                     |
++-----------------------------------------------------------------------------------------------------------------------------------------+
+| AAAAAAAAAA1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000 |
++-----------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A54 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(__time, '|', 100000), 14) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++----------------+
+| col            |
++----------------+
+| 1577840461000| |
++----------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A55 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(__time, '|', 100000), 14, 'A') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++----------------+
+| col            |
++----------------+
+| 1577840461000| |
++----------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A56 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(__time, '|', 100000), 135) AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                     |
++-----------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000           |
++-----------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A57 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(string_agg(__time, '|', 100000), 135, 'A') AS col
+FROM test_agg_funcs
+WHERE __time=timestamp '2020-01-01 01:01:01.000';
++-----------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                     |
++-----------------------------------------------------------------------------------------------------------------------------------------+
+| 1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000|1577840461000AAAAAAAAAA |
++-----------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A58 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(t0.__time, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   WHERE t0.__time IS NOT NULL);
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A59 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(t0.__time, '|', 100000)) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+WHERE t0.__time IS NOT NULL;
+size
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A60 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(col) LEN
+FROM
+  (SELECT string_agg(t0.__time, '|', 100000) AS col
+   FROM test_agg_funcs t0,
+        test_agg_funcs t1,
+        test_agg_funcs t2
+   GROUP BY t0.__time);
++-------+
+| LEN   |
++-------+
+| 40823 |
+| 40823 |
++-------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test004 TEST_ID: A61 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(string_agg(t0.__time, '|', 100000)) AS col
+FROM test_agg_funcs t0,
+     test_agg_funcs t1,
+     test_agg_funcs t2
+GROUP BY t0.__time;
++-------+
+| col   |
++-------+
+| 40823 |
+| 40823 |
++-------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 245 Positive tests: 235 Negative tests: 10
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaArray_ops_funcs.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaArray_ops_funcs.iq
new file mode 100644
index 000000000000..0532a54f6ce2
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaArray_ops_funcs.iq
@@ -0,0 +1,39328 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaArray/ops_funcs&numMergeBuffers=3
+!set outputformat mysql
+SELECT count(*) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_bool + a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[0]' RETURNING boolean array) + json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][0]' RETURNING boolean array) + json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_int + a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[1]' RETURNING bigint array) + json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][1]' RETURNING bigint array) + json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_float + a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[2]' RETURNING decimal array) + json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][2]' RETURNING decimal array) + json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_str + a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[3]' RETURNING varchar array) + json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][3]' RETURNING varchar array) + json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_null + a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[4]' RETURNING varchar array) + json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][4]' RETURNING varchar array) + json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_empty + a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[5]' RETURNING varchar array) + json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][5]' RETURNING varchar array) + json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_mixed + a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[6]' RETURNING varchar array) + json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][6]' RETURNING varchar array) + json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_nested + a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7]' RETURNING varchar array) + json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B1_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][7]' RETURNING varchar array) + json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_bool - a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[0]' RETURNING boolean array) - json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][0]' RETURNING boolean array) - json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_int - a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[1]' RETURNING bigint array) - json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][1]' RETURNING bigint array) - json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_float - a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[2]' RETURNING decimal array) - json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][2]' RETURNING decimal array) - json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_str - a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[3]' RETURNING varchar array) - json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][3]' RETURNING varchar array) - json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_null - a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[4]' RETURNING varchar array) - json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][4]' RETURNING varchar array) - json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_empty - a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[5]' RETURNING varchar array) - json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][5]' RETURNING varchar array) - json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_mixed - a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[6]' RETURNING varchar array) - json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][6]' RETURNING varchar array) - json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_nested - a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7]' RETURNING varchar array) - json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B2_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][7]' RETURNING varchar array) - json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_bool * a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[0]' RETURNING boolean array) * json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][0]' RETURNING boolean array) * json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_int * a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[1]' RETURNING bigint array) * json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][1]' RETURNING bigint array) * json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_float * a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[2]' RETURNING decimal array) * json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][2]' RETURNING decimal array) * json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_str * a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[3]' RETURNING varchar array) * json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][3]' RETURNING varchar array) * json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_null * a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[4]' RETURNING varchar array) * json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][4]' RETURNING varchar array) * json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_empty * a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[5]' RETURNING varchar array) * json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][5]' RETURNING varchar array) * json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_mixed * a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[6]' RETURNING varchar array) * json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][6]' RETURNING varchar array) * json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_nested * a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7]' RETURNING varchar array) * json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B3_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][7]' RETURNING varchar array) * json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_bool / a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[0]' RETURNING boolean array) / json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][0]' RETURNING boolean array) / json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_int / a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[1]' RETURNING bigint array) / json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][1]' RETURNING bigint array) / json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_float / a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[2]' RETURNING decimal array) / json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][2]' RETURNING decimal array) / json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_str / a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[3]' RETURNING varchar array) / json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][3]' RETURNING varchar array) / json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_null / a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[4]' RETURNING varchar array) / json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][4]' RETURNING varchar array) / json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_empty / a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[5]' RETURNING varchar array) / json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][5]' RETURNING varchar array) / json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_mixed / a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[6]' RETURNING varchar array) / json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][6]' RETURNING varchar array) / json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (a_nested / a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7]' RETURNING varchar array) / json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_ops TEST_ID: A1_B4_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (json_value(a_nested, '$[7][7]' RETURNING varchar array) / json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B1_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT pi AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B2_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT abs(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B3_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B4_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT exp(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B5_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B6_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ln(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B7_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT log10(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(a_bool, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(a_int, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(a_float, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(a_str, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(a_null, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(a_empty, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(a_mixed, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B8_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT power(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B9_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sqrt(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B10_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT truncate(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B11_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trunc(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B12_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT round(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(a_bool, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(a_int, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(a_float, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(a_str, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(a_null, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(a_empty, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(a_mixed, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B13_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mod(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B14_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sin(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B15_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cos(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B16_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT tan(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B17_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cot(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B18_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT asin(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B19_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT acos(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B20_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(a_bool, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(a_int, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(a_float, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(a_str, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(a_null, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(a_empty, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(a_mixed, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B21_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT atan2(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B22_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT degrees(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B23_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT radians(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(a_bool, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(a_int, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(a_float, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(a_str, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(a_null, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(a_empty, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(a_mixed, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B24_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_and(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B25_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_complement(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B26_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_double_to_long_bits(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B27_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_convert_long_bits_to_double(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(a_bool, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(a_int, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(a_float, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(a_str, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(a_null, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(a_empty, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(a_mixed, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B28_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_or(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(a_bool, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(a_int, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(a_float, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(a_str, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(a_null, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(a_empty, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(a_mixed, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B29_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_left(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(a_bool, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(a_int, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(a_float, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(a_str, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(a_null, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(a_empty, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(a_mixed, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B30_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_shift_right(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(a_bool, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(a_int, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(a_float, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(a_str, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(a_null, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(a_empty, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(a_mixed, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B31_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bitwise_xor(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(a_bool, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(a_int, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(a_float, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(a_str, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(a_null, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(a_empty, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(a_mixed, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B33_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_binary_byte_format(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(a_bool, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(a_int, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(a_float, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(a_str, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(a_null, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(a_empty, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(a_mixed, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B34_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_byte_format(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(a_bool, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(a_int, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(a_float, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(a_str, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(a_null, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(a_empty, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(a_mixed, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B35_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT human_readable_decimal_format(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(a_bool, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(a_int, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(a_float, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(a_str, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(a_null, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(a_empty, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(a_mixed, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A1_B36_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT safe_divide(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(a_bool, 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(json_value(a_nested, '$[0]' RETURNING boolean array), 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(json_value(a_nested, '$[7][0]' RETURNING boolean array), 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(a_int, 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(json_value(a_nested, '$[1]' RETURNING bigint array), 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(json_value(a_nested, '$[7][1]' RETURNING bigint array), 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(a_float, 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(json_value(a_nested, '$[2]' RETURNING decimal array), 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(json_value(a_nested, '$[7][2]' RETURNING decimal array), 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(a_str, 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(json_value(a_nested, '$[3]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(json_value(a_nested, '$[7][3]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(a_null, 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(json_value(a_nested, '$[4]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(json_value(a_nested, '$[7][4]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(a_empty, 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(json_value(a_nested, '$[5]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(json_value(a_nested, '$[7][5]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(a_mixed, 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(json_value(a_nested, '$[6]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(json_value(a_nested, '$[7][6]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(a_nested, 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(json_value(a_nested, '$[7]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B1_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT concat(json_value(a_nested, '$[7][7]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(a_bool, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(json_value(a_nested, '$[0]' RETURNING boolean array), 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(json_value(a_nested, '$[7][0]' RETURNING boolean array), 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(a_int, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(json_value(a_nested, '$[1]' RETURNING bigint array), 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(json_value(a_nested, '$[7][1]' RETURNING bigint array), 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(a_float, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(json_value(a_nested, '$[2]' RETURNING decimal array), 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(json_value(a_nested, '$[7][2]' RETURNING decimal array), 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(a_str, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(json_value(a_nested, '$[3]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(json_value(a_nested, '$[7][3]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(a_null, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(json_value(a_nested, '$[4]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(json_value(a_nested, '$[7][4]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(a_empty, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(json_value(a_nested, '$[5]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(json_value(a_nested, '$[7][5]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(a_mixed, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(json_value(a_nested, '$[6]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(json_value(a_nested, '$[7][6]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(a_nested, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(json_value(a_nested, '$[7]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B2_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT textcat(json_value(a_nested, '$[7][7]' RETURNING varchar array), 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', a_bool) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', a_int) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', a_float) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', a_str) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', a_null) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', a_empty) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', a_mixed) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C22_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', a_nested) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B3_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT string_format('%sZ', json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B4_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT length(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B5_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT char_length(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B6_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT character_length(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B7_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strlen(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B8_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lower(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B9_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT upper(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B10_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_long(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN a_bool) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN a_int) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN a_float) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN a_str) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN a_null) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN a_empty) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN a_mixed) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN a_nested) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B11_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT position('ABCD' IN json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(a_bool, '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(json_value(a_nested, '$[0]' RETURNING boolean array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(json_value(a_nested, '$[7][0]' RETURNING boolean array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(a_int, '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(json_value(a_nested, '$[1]' RETURNING bigint array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(json_value(a_nested, '$[7][1]' RETURNING bigint array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(a_float, '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(json_value(a_nested, '$[2]' RETURNING decimal array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(json_value(a_nested, '$[7][2]' RETURNING decimal array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(a_str, '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(json_value(a_nested, '$[3]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(json_value(a_nested, '$[7][3]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(a_null, '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(json_value(a_nested, '$[4]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(json_value(a_nested, '$[7][4]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(a_empty, '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(json_value(a_nested, '$[5]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(json_value(a_nested, '$[7][5]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(a_mixed, '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(json_value(a_nested, '$[6]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(json_value(a_nested, '$[7][6]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(a_nested, '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(json_value(a_nested, '$[7]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B12_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_extract(json_value(a_nested, '$[7][7]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(a_bool, '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(json_value(a_nested, '$[0]' RETURNING boolean array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(json_value(a_nested, '$[7][0]' RETURNING boolean array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(a_int, '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(json_value(a_nested, '$[1]' RETURNING bigint array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(json_value(a_nested, '$[7][1]' RETURNING bigint array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(a_float, '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(json_value(a_nested, '$[2]' RETURNING decimal array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(json_value(a_nested, '$[7][2]' RETURNING decimal array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(a_str, '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(json_value(a_nested, '$[3]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(json_value(a_nested, '$[7][3]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(a_null, '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(json_value(a_nested, '$[4]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(json_value(a_nested, '$[7][4]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(a_empty, '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(json_value(a_nested, '$[5]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(json_value(a_nested, '$[7][5]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(a_mixed, '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(json_value(a_nested, '$[6]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(json_value(a_nested, '$[7][6]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(a_nested, '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(json_value(a_nested, '$[7]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B13_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT regexp_like(json_value(a_nested, '$[7][7]' RETURNING varchar array), '.*') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(a_bool, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(json_value(a_nested, '$[0]' RETURNING boolean array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(json_value(a_nested, '$[7][0]' RETURNING boolean array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(a_int, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(json_value(a_nested, '$[1]' RETURNING bigint array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(json_value(a_nested, '$[7][1]' RETURNING bigint array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(a_float, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(json_value(a_nested, '$[2]' RETURNING decimal array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(json_value(a_nested, '$[7][2]' RETURNING decimal array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(a_str, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(json_value(a_nested, '$[3]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(json_value(a_nested, '$[7][3]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(a_null, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(json_value(a_nested, '$[4]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(json_value(a_nested, '$[7][4]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(a_empty, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(json_value(a_nested, '$[5]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(json_value(a_nested, '$[7][5]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(a_mixed, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(json_value(a_nested, '$[6]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(json_value(a_nested, '$[7][6]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(a_nested, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(json_value(a_nested, '$[7]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B14_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT contains_string(json_value(a_nested, '$[7][7]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(a_bool, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(json_value(a_nested, '$[0]' RETURNING boolean array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(json_value(a_nested, '$[7][0]' RETURNING boolean array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(a_int, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(json_value(a_nested, '$[1]' RETURNING bigint array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(json_value(a_nested, '$[7][1]' RETURNING bigint array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(a_float, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(json_value(a_nested, '$[2]' RETURNING decimal array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(json_value(a_nested, '$[7][2]' RETURNING decimal array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(a_str, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(json_value(a_nested, '$[3]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(json_value(a_nested, '$[7][3]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(a_null, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(json_value(a_nested, '$[4]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(json_value(a_nested, '$[7][4]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(a_empty, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(json_value(a_nested, '$[5]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(json_value(a_nested, '$[7][5]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(a_mixed, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(json_value(a_nested, '$[6]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(json_value(a_nested, '$[7][6]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(a_nested, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(json_value(a_nested, '$[7]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B15_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT icontains_string(json_value(a_nested, '$[7][7]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(a_bool, 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(json_value(a_nested, '$[0]' RETURNING boolean array), 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(json_value(a_nested, '$[7][0]' RETURNING boolean array), 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(a_int, 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(json_value(a_nested, '$[1]' RETURNING bigint array), 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(json_value(a_nested, '$[7][1]' RETURNING bigint array), 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(a_float, 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(json_value(a_nested, '$[2]' RETURNING decimal array), 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(json_value(a_nested, '$[7][2]' RETURNING decimal array), 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(a_str, 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(json_value(a_nested, '$[3]' RETURNING varchar array), 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(json_value(a_nested, '$[7][3]' RETURNING varchar array), 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(a_null, 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(json_value(a_nested, '$[4]' RETURNING varchar array), 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(json_value(a_nested, '$[7][4]' RETURNING varchar array), 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(a_empty, 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(json_value(a_nested, '$[5]' RETURNING varchar array), 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(json_value(a_nested, '$[7][5]' RETURNING varchar array), 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(a_mixed, 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(json_value(a_nested, '$[6]' RETURNING varchar array), 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(json_value(a_nested, '$[7][6]' RETURNING varchar array), 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(a_nested, 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(json_value(a_nested, '$[7]' RETURNING varchar array), 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B16_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT replace(json_value(a_nested, '$[7][7]' RETURNING varchar array), 'A', 'B') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(a_bool, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(json_value(a_nested, '$[0]' RETURNING boolean array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(json_value(a_nested, '$[7][0]' RETURNING boolean array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(a_int, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(json_value(a_nested, '$[1]' RETURNING bigint array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(json_value(a_nested, '$[7][1]' RETURNING bigint array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(a_float, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(json_value(a_nested, '$[2]' RETURNING decimal array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(json_value(a_nested, '$[7][2]' RETURNING decimal array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(a_str, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(json_value(a_nested, '$[3]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(json_value(a_nested, '$[7][3]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(a_null, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(json_value(a_nested, '$[4]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(json_value(a_nested, '$[7][4]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(a_empty, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(json_value(a_nested, '$[5]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(json_value(a_nested, '$[7][5]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(a_mixed, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(json_value(a_nested, '$[6]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(json_value(a_nested, '$[7][6]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(a_nested, 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(json_value(a_nested, '$[7]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B17_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT strpos(json_value(a_nested, '$[7][7]' RETURNING varchar array), 'ABCD') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(a_bool, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(a_int, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(a_float, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(a_str, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(a_null, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(a_empty, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(a_mixed, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B18_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substring(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(a_bool, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(a_int, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(a_float, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(a_str, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(a_null, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(a_empty, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(a_mixed, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B19_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT right(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(a_bool, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(a_int, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(a_float, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(a_str, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(a_null, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(a_empty, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(a_mixed, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B20_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT left(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(a_bool, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(a_int, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(a_float, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(a_str, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(a_null, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(a_empty, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(a_mixed, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B21_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT substr(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B22_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT trim(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B23_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT btrim(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B24_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ltrim(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B25_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rtrim(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B26_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT reverse(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(a_bool, 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(json_value(a_nested, '$[0]' RETURNING boolean array), 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(json_value(a_nested, '$[7][0]' RETURNING boolean array), 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(a_int, 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(json_value(a_nested, '$[1]' RETURNING bigint array), 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(json_value(a_nested, '$[7][1]' RETURNING bigint array), 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(a_float, 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(json_value(a_nested, '$[2]' RETURNING decimal array), 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(json_value(a_nested, '$[7][2]' RETURNING decimal array), 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(a_str, 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(json_value(a_nested, '$[3]' RETURNING varchar array), 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(json_value(a_nested, '$[7][3]' RETURNING varchar array), 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(a_null, 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(json_value(a_nested, '$[4]' RETURNING varchar array), 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(json_value(a_nested, '$[7][4]' RETURNING varchar array), 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(a_empty, 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(json_value(a_nested, '$[5]' RETURNING varchar array), 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(json_value(a_nested, '$[7][5]' RETURNING varchar array), 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(a_mixed, 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(json_value(a_nested, '$[6]' RETURNING varchar array), 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(json_value(a_nested, '$[7][6]' RETURNING varchar array), 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(a_nested, 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(json_value(a_nested, '$[7]' RETURNING varchar array), 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B27_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT repeat(json_value(a_nested, '$[7][7]' RETURNING varchar array), 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(a_bool, 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(json_value(a_nested, '$[0]' RETURNING boolean array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(json_value(a_nested, '$[7][0]' RETURNING boolean array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(a_int, 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(json_value(a_nested, '$[1]' RETURNING bigint array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(json_value(a_nested, '$[7][1]' RETURNING bigint array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(a_float, 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(json_value(a_nested, '$[2]' RETURNING decimal array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(json_value(a_nested, '$[7][2]' RETURNING decimal array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(a_str, 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(json_value(a_nested, '$[3]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(json_value(a_nested, '$[7][3]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(a_null, 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(json_value(a_nested, '$[4]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(json_value(a_nested, '$[7][4]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(a_empty, 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(json_value(a_nested, '$[5]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(json_value(a_nested, '$[7][5]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(a_mixed, 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(json_value(a_nested, '$[6]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(json_value(a_nested, '$[7][6]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(a_nested, 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(json_value(a_nested, '$[7]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B28_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT lpad(json_value(a_nested, '$[7][7]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(a_bool, 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(json_value(a_nested, '$[0]' RETURNING boolean array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(json_value(a_nested, '$[7][0]' RETURNING boolean array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(a_int, 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(json_value(a_nested, '$[1]' RETURNING bigint array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(json_value(a_nested, '$[7][1]' RETURNING bigint array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(a_float, 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(json_value(a_nested, '$[2]' RETURNING decimal array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(json_value(a_nested, '$[7][2]' RETURNING decimal array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(a_str, 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(json_value(a_nested, '$[3]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(json_value(a_nested, '$[7][3]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(a_null, 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(json_value(a_nested, '$[4]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(json_value(a_nested, '$[7][4]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(a_empty, 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(json_value(a_nested, '$[5]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(json_value(a_nested, '$[7][5]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(a_mixed, 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(json_value(a_nested, '$[6]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(json_value(a_nested, '$[7][6]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(a_nested, 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(json_value(a_nested, '$[7]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A2_B29_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT rpad(json_value(a_nested, '$[7][7]' RETURNING varchar array), 2, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B1_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT CURRENT_TIMESTAMP AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B2_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT CURRENT_DATE AS col
+   FROM test_array);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B3_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT date_trunc('year', json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(a_bool, 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(json_value(a_nested, '$[0]' RETURNING boolean array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(json_value(a_nested, '$[7][0]' RETURNING boolean array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(a_int, 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(json_value(a_nested, '$[1]' RETURNING bigint array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(json_value(a_nested, '$[7][1]' RETURNING bigint array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(a_float, 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(json_value(a_nested, '$[2]' RETURNING decimal array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(json_value(a_nested, '$[7][2]' RETURNING decimal array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(a_str, 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(json_value(a_nested, '$[3]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(json_value(a_nested, '$[7][3]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(a_null, 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(json_value(a_nested, '$[4]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(json_value(a_nested, '$[7][4]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(a_empty, 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(json_value(a_nested, '$[5]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(json_value(a_nested, '$[7][5]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(a_mixed, 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(json_value(a_nested, '$[6]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(json_value(a_nested, '$[7][6]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(a_nested, 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(json_value(a_nested, '$[7]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B4_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_ceil(json_value(a_nested, '$[7][7]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(a_bool, 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(json_value(a_nested, '$[0]' RETURNING boolean array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(json_value(a_nested, '$[7][0]' RETURNING boolean array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(a_int, 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(json_value(a_nested, '$[1]' RETURNING bigint array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(json_value(a_nested, '$[7][1]' RETURNING bigint array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(a_float, 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(json_value(a_nested, '$[2]' RETURNING decimal array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(json_value(a_nested, '$[7][2]' RETURNING decimal array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(a_str, 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(json_value(a_nested, '$[3]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(json_value(a_nested, '$[7][3]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(a_null, 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(json_value(a_nested, '$[4]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(json_value(a_nested, '$[7][4]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(a_empty, 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(json_value(a_nested, '$[5]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(json_value(a_nested, '$[7][5]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(a_mixed, 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(json_value(a_nested, '$[6]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(json_value(a_nested, '$[7][6]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(a_nested, 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(json_value(a_nested, '$[7]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B5_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_floor(json_value(a_nested, '$[7][7]' RETURNING varchar array), 'P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(a_bool, 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(json_value(a_nested, '$[0]' RETURNING boolean array), 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(json_value(a_nested, '$[7][0]' RETURNING boolean array), 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(a_int, 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(json_value(a_nested, '$[1]' RETURNING bigint array), 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(json_value(a_nested, '$[7][1]' RETURNING bigint array), 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(a_float, 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(json_value(a_nested, '$[2]' RETURNING decimal array), 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(json_value(a_nested, '$[7][2]' RETURNING decimal array), 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(a_str, 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(json_value(a_nested, '$[3]' RETURNING varchar array), 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(json_value(a_nested, '$[7][3]' RETURNING varchar array), 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(a_null, 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(json_value(a_nested, '$[4]' RETURNING varchar array), 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(json_value(a_nested, '$[7][4]' RETURNING varchar array), 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(a_empty, 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(json_value(a_nested, '$[5]' RETURNING varchar array), 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(json_value(a_nested, '$[7][5]' RETURNING varchar array), 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(a_mixed, 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(json_value(a_nested, '$[6]' RETURNING varchar array), 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(json_value(a_nested, '$[7][6]' RETURNING varchar array), 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(a_nested, 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(json_value(a_nested, '$[7]' RETURNING varchar array), 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B6_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_shift(json_value(a_nested, '$[7][7]' RETURNING varchar array), 'P1D', 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(a_bool, 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(json_value(a_nested, '$[0]' RETURNING boolean array), 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(json_value(a_nested, '$[7][0]' RETURNING boolean array), 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(a_int, 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(json_value(a_nested, '$[1]' RETURNING bigint array), 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(json_value(a_nested, '$[7][1]' RETURNING bigint array), 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(a_float, 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(json_value(a_nested, '$[2]' RETURNING decimal array), 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(json_value(a_nested, '$[7][2]' RETURNING decimal array), 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(a_str, 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(json_value(a_nested, '$[3]' RETURNING varchar array), 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(json_value(a_nested, '$[7][3]' RETURNING varchar array), 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(a_null, 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(json_value(a_nested, '$[4]' RETURNING varchar array), 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(json_value(a_nested, '$[7][4]' RETURNING varchar array), 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(a_empty, 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(json_value(a_nested, '$[5]' RETURNING varchar array), 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(json_value(a_nested, '$[7][5]' RETURNING varchar array), 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(a_mixed, 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(json_value(a_nested, '$[6]' RETURNING varchar array), 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(json_value(a_nested, '$[7][6]' RETURNING varchar array), 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(a_nested, 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(json_value(a_nested, '$[7]' RETURNING varchar array), 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B7_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_extract(json_value(a_nested, '$[7][7]' RETURNING varchar array), 'HOUR') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B8_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_parse(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(a_bool, '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(json_value(a_nested, '$[0]' RETURNING boolean array), '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(json_value(a_nested, '$[7][0]' RETURNING boolean array), '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(a_int, '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(json_value(a_nested, '$[1]' RETURNING bigint array), '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(json_value(a_nested, '$[7][1]' RETURNING bigint array), '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(a_float, '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(json_value(a_nested, '$[2]' RETURNING decimal array), '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(json_value(a_nested, '$[7][2]' RETURNING decimal array), '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(a_str, '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(json_value(a_nested, '$[3]' RETURNING varchar array), '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(json_value(a_nested, '$[7][3]' RETURNING varchar array), '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(a_null, '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(json_value(a_nested, '$[4]' RETURNING varchar array), '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(json_value(a_nested, '$[7][4]' RETURNING varchar array), '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(a_empty, '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(json_value(a_nested, '$[5]' RETURNING varchar array), '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(json_value(a_nested, '$[7][5]' RETURNING varchar array), '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(a_mixed, '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(json_value(a_nested, '$[6]' RETURNING varchar array), '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(json_value(a_nested, '$[7][6]' RETURNING varchar array), '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(a_nested, '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(json_value(a_nested, '$[7]' RETURNING varchar array), '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B9_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT time_in_interval(json_value(a_nested, '$[7][7]' RETURNING varchar array), '2001-01-01/P1D') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B10_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT millis_to_timestamp(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B11_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestamp_to_millis(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B12_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT extract(DAY
+               FROM json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(a_bool TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[0]' RETURNING boolean array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[7][0]' RETURNING boolean array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(a_int TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[1]' RETURNING bigint array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[7][1]' RETURNING bigint array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(a_float TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[2]' RETURNING decimal array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[7][2]' RETURNING decimal array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(a_str TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[3]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[7][3]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(a_null TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[4]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[7][4]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(a_empty TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[5]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[7][5]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(a_mixed TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[6]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[7][6]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(a_nested TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[7]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B13_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT floor(json_value(a_nested, '$[7][7]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(a_bool TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[0]' RETURNING boolean array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[7][0]' RETURNING boolean array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(a_int TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[1]' RETURNING bigint array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[7][1]' RETURNING bigint array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(a_float TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[2]' RETURNING decimal array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[7][2]' RETURNING decimal array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(a_str TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[3]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[7][3]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(a_null TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[4]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[7][4]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(a_empty TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[5]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[7][5]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(a_mixed TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[6]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[7][6]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(a_nested TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[7]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B14_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ceil(json_value(a_nested, '$[7][7]' RETURNING varchar array) TO DAY) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B15_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampadd(DAY, 1, json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A3_B16_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT timestampdiff(DAY, CURRENT_TIMESTAMP, json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(a_bool, a_bool) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(json_value(a_nested, '$[0]' RETURNING boolean array), json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(json_value(a_nested, '$[7][0]' RETURNING boolean array), json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(a_int, a_int) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(json_value(a_nested, '$[1]' RETURNING bigint array), json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(json_value(a_nested, '$[7][1]' RETURNING bigint array), json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(a_float, a_float) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(json_value(a_nested, '$[2]' RETURNING decimal array), json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(json_value(a_nested, '$[7][2]' RETURNING decimal array), json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(a_str, a_str) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(json_value(a_nested, '$[3]' RETURNING varchar array), json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(json_value(a_nested, '$[7][3]' RETURNING varchar array), json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(a_null, a_null) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(json_value(a_nested, '$[4]' RETURNING varchar array), json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(json_value(a_nested, '$[7][4]' RETURNING varchar array), json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(a_empty, a_empty) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(json_value(a_nested, '$[5]' RETURNING varchar array), json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(json_value(a_nested, '$[7][5]' RETURNING varchar array), json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(a_mixed, a_mixed) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(json_value(a_nested, '$[6]' RETURNING varchar array), json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(json_value(a_nested, '$[7][6]' RETURNING varchar array), json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(a_nested, a_nested) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(json_value(a_nested, '$[7]' RETURNING varchar array), json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B1_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT greatest(json_value(a_nested, '$[7][7]' RETURNING varchar array), json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(a_bool, a_bool) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(json_value(a_nested, '$[0]' RETURNING boolean array), json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(json_value(a_nested, '$[7][0]' RETURNING boolean array), json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(a_int, a_int) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(json_value(a_nested, '$[1]' RETURNING bigint array), json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(json_value(a_nested, '$[7][1]' RETURNING bigint array), json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(a_float, a_float) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(json_value(a_nested, '$[2]' RETURNING decimal array), json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(json_value(a_nested, '$[7][2]' RETURNING decimal array), json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(a_str, a_str) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(json_value(a_nested, '$[3]' RETURNING varchar array), json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(json_value(a_nested, '$[7][3]' RETURNING varchar array), json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(a_null, a_null) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(json_value(a_nested, '$[4]' RETURNING varchar array), json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(json_value(a_nested, '$[7][4]' RETURNING varchar array), json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(a_empty, a_empty) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(json_value(a_nested, '$[5]' RETURNING varchar array), json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(json_value(a_nested, '$[7][5]' RETURNING varchar array), json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(a_mixed, a_mixed) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(json_value(a_nested, '$[6]' RETURNING varchar array), json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(json_value(a_nested, '$[7][6]' RETURNING varchar array), json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(a_nested, a_nested) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(json_value(a_nested, '$[7]' RETURNING varchar array), json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A4_B2_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT least(json_value(a_nested, '$[7][7]' RETURNING varchar array), json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(a_bool, '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(json_value(a_nested, '$[0]' RETURNING boolean array), '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(json_value(a_nested, '$[7][0]' RETURNING boolean array), '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(a_int, '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(json_value(a_nested, '$[1]' RETURNING bigint array), '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(json_value(a_nested, '$[7][1]' RETURNING bigint array), '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(a_float, '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(json_value(a_nested, '$[2]' RETURNING decimal array), '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(json_value(a_nested, '$[7][2]' RETURNING decimal array), '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(a_str, '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(json_value(a_nested, '$[3]' RETURNING varchar array), '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(json_value(a_nested, '$[7][3]' RETURNING varchar array), '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(a_null, '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(json_value(a_nested, '$[4]' RETURNING varchar array), '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(json_value(a_nested, '$[7][4]' RETURNING varchar array), '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(a_empty, '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(json_value(a_nested, '$[5]' RETURNING varchar array), '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(json_value(a_nested, '$[7][5]' RETURNING varchar array), '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(a_mixed, '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(json_value(a_nested, '$[6]' RETURNING varchar array), '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(json_value(a_nested, '$[7][6]' RETURNING varchar array), '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(a_nested, '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(json_value(a_nested, '$[7]' RETURNING varchar array), '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B1_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_match(json_value(a_nested, '$[7][7]' RETURNING varchar array), '255.0.0.0/1') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B2_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_parse(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(a_bool) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(a_int) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(a_float) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(a_str) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(a_null) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(a_empty) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(a_mixed) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A5_B3_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ipv4_stringify(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(a_bool AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(a_nested, '$[0]' RETURNING boolean array) AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(a_nested, '$[7][0]' RETURNING boolean array) AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(a_int AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(a_nested, '$[1]' RETURNING bigint array) AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(a_nested, '$[7][1]' RETURNING bigint array) AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(a_float AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(a_nested, '$[2]' RETURNING decimal array) AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(a_nested, '$[7][2]' RETURNING decimal array) AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(a_str AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(a_nested, '$[3]' RETURNING varchar array) AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(a_nested, '$[7][3]' RETURNING varchar array) AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(a_null AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(a_nested, '$[4]' RETURNING varchar array) AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(a_nested, '$[7][4]' RETURNING varchar array) AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(a_empty AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(a_nested, '$[5]' RETURNING varchar array) AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(a_nested, '$[7][5]' RETURNING varchar array) AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(a_mixed AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(a_nested, '$[6]' RETURNING varchar array) AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(a_nested, '$[7][6]' RETURNING varchar array) AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(a_nested AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(a_nested, '$[7]' RETURNING varchar array) AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B1_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(a_nested, '$[7][7]' RETURNING varchar array) AS varchar) AS col
+FROM test_array;
+cannot convert
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE a_bool
+            WHEN ARRAY[1,
+                       0,
+                       NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE json_value(a_nested, '$[0]' RETURNING boolean array)
+            WHEN ARRAY[1,
+                       0,
+                       NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE json_value(a_nested, '$[7][0]' RETURNING boolean array)
+            WHEN ARRAY[1,
+                       0,
+                       NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE a_int
+            WHEN ARRAY[1,
+                       2,
+                       NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE json_value(a_nested, '$[1]' RETURNING bigint array)
+            WHEN ARRAY[1,
+                       2,
+                       NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE json_value(a_nested, '$[7][1]' RETURNING bigint array)
+            WHEN ARRAY[1,
+                       2,
+                       NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE a_float
+            WHEN ARRAY[0.1,
+                       0.2,
+                       NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE json_value(a_nested, '$[2]' RETURNING decimal array)
+            WHEN ARRAY[0.1,
+                       0.2,
+                       NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE json_value(a_nested, '$[7][2]' RETURNING decimal array)
+            WHEN ARRAY[0.1,
+                       0.2,
+                       NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE a_str
+            WHEN ARRAY['S1',
+                       'S2',
+                       NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE json_value(a_nested, '$[3]' RETURNING varchar array)
+            WHEN ARRAY['S1',
+                       'S2',
+                       NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE json_value(a_nested, '$[7][3]' RETURNING varchar array)
+            WHEN ARRAY['S1',
+                       'S2',
+                       NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE a_null
+            WHEN ARRAY[NULL,
+                       NULL,
+                       NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE json_value(a_nested, '$[4]' RETURNING varchar array)
+            WHEN ARRAY[NULL,
+                       NULL,
+                       NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE json_value(a_nested, '$[7][4]' RETURNING varchar array)
+            WHEN ARRAY[NULL,
+                       NULL,
+                       NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE a_empty
+            WHEN ARRAY['FILLER'] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE json_value(a_nested, '$[5]' RETURNING varchar array)
+            WHEN ARRAY['FILLER'] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE json_value(a_nested, '$[7][5]' RETURNING varchar array)
+            WHEN ARRAY['FILLER'] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE a_mixed
+            WHEN ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE json_value(a_nested, '$[6]' RETURNING varchar array)
+            WHEN ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE json_value(a_nested, '$[7][6]' RETURNING varchar array)
+            WHEN ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE a_nested
+            WHEN ARRAY['FILLER'] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE json_value(a_nested, '$[7]' RETURNING varchar array)
+            WHEN ARRAY['FILLER'] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B2_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE json_value(a_nested, '$[7][7]' RETURNING varchar array)
+            WHEN ARRAY['FILLER'] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN a_bool=ARRAY[1,
+                              0,
+                              NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN json_value(a_nested, '$[0]' RETURNING boolean array)=ARRAY[1,
+                                                                            0,
+                                                                            NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN json_value(a_nested, '$[7][0]' RETURNING boolean array)=ARRAY[1,
+                                                                               0,
+                                                                               NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN a_int=ARRAY[1,
+                             2,
+                             NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN json_value(a_nested, '$[1]' RETURNING bigint array)=ARRAY[1,
+                                                                           2,
+                                                                           NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN json_value(a_nested, '$[7][1]' RETURNING bigint array)=ARRAY[1,
+                                                                              2,
+                                                                              NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN a_float=ARRAY[0.1,
+                               0.2,
+                               NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN json_value(a_nested, '$[2]' RETURNING decimal array)=ARRAY[0.1,
+                                                                            0.2,
+                                                                            NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN json_value(a_nested, '$[7][2]' RETURNING decimal array)=ARRAY[0.1,
+                                                                               0.2,
+                                                                               NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN a_str=ARRAY['S1',
+                             'S2',
+                             NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN json_value(a_nested, '$[3]' RETURNING varchar array)=ARRAY['S1',
+                                                                            'S2',
+                                                                            NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN json_value(a_nested, '$[7][3]' RETURNING varchar array)=ARRAY['S1',
+                                                                               'S2',
+                                                                               NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN a_null=ARRAY[NULL,
+                              NULL,
+                              NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN json_value(a_nested, '$[4]' RETURNING varchar array)=ARRAY[NULL,
+                                                                            NULL,
+                                                                            NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN json_value(a_nested, '$[7][4]' RETURNING varchar array)=ARRAY[NULL,
+                                                                               NULL,
+                                                                               NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   1 |
+|   1 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN a_empty=ARRAY['FILLER'] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN json_value(a_nested, '$[5]' RETURNING varchar array)=ARRAY['FILLER'] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN json_value(a_nested, '$[7][5]' RETURNING varchar array)=ARRAY['FILLER'] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN a_mixed=ARRAY['true',
+                               '1',
+                               '0.1',
+                               'S1',
+                               NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN json_value(a_nested, '$[6]' RETURNING varchar array)=ARRAY['true',
+                                                                            '1',
+                                                                            '0.1',
+                                                                            'S1',
+                                                                            NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN json_value(a_nested, '$[7][6]' RETURNING varchar array)=ARRAY['true',
+                                                                               '1',
+                                                                               '0.1',
+                                                                               'S1',
+                                                                               NULL] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN a_nested=ARRAY['FILLER'] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN json_value(a_nested, '$[7]' RETURNING varchar array)=ARRAY['FILLER'] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B3_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (CASE
+            WHEN json_value(a_nested, '$[7][7]' RETURNING varchar array)=ARRAY['FILLER'] THEN 1
+            ELSE 2
+        END) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(a_bool, ARRAY[1, 0, NULL]) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
+|              |
+|              |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(a_int, ARRAY[1, 2, NULL]) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
+|              |
+|              |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(json_value(a_nested, '$[1]' RETURNING bigint array), ARRAY[1, 2, NULL]) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
+|              |
+|              |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(json_value(a_nested, '$[7][1]' RETURNING bigint array), ARRAY[1, 2, NULL]) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
+|              |
+|              |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(a_float, ARRAY[0.1, 0.2, NULL]) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+|                  |
+|                  |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(json_value(a_nested, '$[2]' RETURNING decimal array), ARRAY[0.1, 0.2, NULL]) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+|                  |
+|                  |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(json_value(a_nested, '$[7][2]' RETURNING decimal array), ARRAY[0.1, 0.2, NULL]) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+|                  |
+|                  |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(a_str, ARRAY['S1', 'S2', NULL]) AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
+|                |
+|                |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(json_value(a_nested, '$[3]' RETURNING varchar array), ARRAY['S1', 'S2', NULL]) AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
+|                |
+|                |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(json_value(a_nested, '$[7][3]' RETURNING varchar array), ARRAY['S1', 'S2', NULL]) AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
+|                |
+|                |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(a_null, ARRAY[NULL, NULL, NULL]) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(json_value(a_nested, '$[4]' RETURNING varchar array), ARRAY[NULL, NULL, NULL]) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(json_value(a_nested, '$[7][4]' RETURNING varchar array), ARRAY[NULL, NULL, NULL]) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(a_empty, ARRAY['FILLER']) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(json_value(a_nested, '$[5]' RETURNING varchar array), ARRAY['FILLER']) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(json_value(a_nested, '$[7][5]' RETURNING varchar array), ARRAY['FILLER']) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(a_mixed, ARRAY['true', '1', '0.1', 'S1', NULL]) AS col
+FROM test_array;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+|                          |
+|                          |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(json_value(a_nested, '$[6]' RETURNING varchar array), ARRAY['true', '1', '0.1', 'S1', NULL]) AS col
+FROM test_array;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+|                          |
+|                          |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(json_value(a_nested, '$[7][6]' RETURNING varchar array), ARRAY['true', '1', '0.1', 'S1', NULL]) AS col
+FROM test_array;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+|                          |
+|                          |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(a_nested, ARRAY['FILLER']) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(json_value(a_nested, '$[7]' RETURNING varchar array), ARRAY['FILLER']) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B4_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nullif(json_value(a_nested, '$[7][7]' RETURNING varchar array), ARRAY['FILLER']) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(a_bool, ARRAY[1, 0, NULL]) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(json_value(a_nested, '$[0]' RETURNING boolean array), ARRAY[1, 0, NULL]) AS col
+FROM test_array;
+Illegal
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(json_value(a_nested, '$[7][0]' RETURNING boolean array), ARRAY[1, 0, NULL]) AS col
+FROM test_array;
+Illegal
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(a_int, ARRAY[1, 2, NULL]) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(json_value(a_nested, '$[1]' RETURNING bigint array), ARRAY[1, 2, NULL]) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(json_value(a_nested, '$[7][1]' RETURNING bigint array), ARRAY[1, 2, NULL]) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(a_float, ARRAY[0.1, 0.2, NULL]) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(json_value(a_nested, '$[2]' RETURNING decimal array), ARRAY[0.1, 0.2, NULL]) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(json_value(a_nested, '$[7][2]' RETURNING decimal array), ARRAY[0.1, 0.2, NULL]) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(a_str, ARRAY['S1', 'S2', NULL]) AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(json_value(a_nested, '$[3]' RETURNING varchar array), ARRAY['S1', 'S2', NULL]) AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(json_value(a_nested, '$[7][3]' RETURNING varchar array), ARRAY['S1', 'S2', NULL]) AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(a_null, ARRAY[NULL, NULL, NULL]) AS col
+FROM test_array;
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(json_value(a_nested, '$[4]' RETURNING varchar array), ARRAY[NULL, NULL, NULL]) AS col
+FROM test_array;
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(json_value(a_nested, '$[7][4]' RETURNING varchar array), ARRAY[NULL, NULL, NULL]) AS col
+FROM test_array;
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(a_empty, ARRAY['FILLER']) AS col
+FROM test_array;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(json_value(a_nested, '$[5]' RETURNING varchar array), ARRAY['FILLER']) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(json_value(a_nested, '$[7][5]' RETURNING varchar array), ARRAY['FILLER']) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(a_mixed, ARRAY['true', '1', '0.1', 'S1', NULL]) AS col
+FROM test_array;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(json_value(a_nested, '$[6]' RETURNING varchar array), ARRAY['true', '1', '0.1', 'S1', NULL]) AS col
+FROM test_array;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(json_value(a_nested, '$[7][6]' RETURNING varchar array), ARRAY['true', '1', '0.1', 'S1', NULL]) AS col
+FROM test_array;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(a_nested, ARRAY['FILLER']) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(json_value(a_nested, '$[7]' RETURNING varchar array), ARRAY['FILLER']) AS col
+FROM test_array;
++----------+
+| col      |
++----------+
+| [FILLER] |
+| [FILLER] |
+| [FILLER] |
+| [FILLER] |
++----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B5_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT coalesce(json_value(a_nested, '$[7][7]' RETURNING varchar array), ARRAY['FILLER']) AS col
+FROM test_array;
++----------+
+| col      |
++----------+
+| [FILLER] |
+| [FILLER] |
+| [FILLER] |
+| [FILLER] |
++----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(a_bool, ARRAY[1, 0, NULL]) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(json_value(a_nested, '$[0]' RETURNING boolean array), ARRAY[1, 0, NULL]) AS col
+FROM test_array;
+Illegal
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(json_value(a_nested, '$[7][0]' RETURNING boolean array), ARRAY[1, 0, NULL]) AS col
+FROM test_array;
+Illegal
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(a_int, ARRAY[1, 2, NULL]) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(json_value(a_nested, '$[1]' RETURNING bigint array), ARRAY[1, 2, NULL]) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(json_value(a_nested, '$[7][1]' RETURNING bigint array), ARRAY[1, 2, NULL]) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(a_float, ARRAY[0.1, 0.2, NULL]) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(json_value(a_nested, '$[2]' RETURNING decimal array), ARRAY[0.1, 0.2, NULL]) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(json_value(a_nested, '$[7][2]' RETURNING decimal array), ARRAY[0.1, 0.2, NULL]) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(a_str, ARRAY['S1', 'S2', NULL]) AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(json_value(a_nested, '$[3]' RETURNING varchar array), ARRAY['S1', 'S2', NULL]) AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(json_value(a_nested, '$[7][3]' RETURNING varchar array), ARRAY['S1', 'S2', NULL]) AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(a_null, ARRAY[NULL, NULL, NULL]) AS col
+FROM test_array;
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(json_value(a_nested, '$[4]' RETURNING varchar array), ARRAY[NULL, NULL, NULL]) AS col
+FROM test_array;
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(json_value(a_nested, '$[7][4]' RETURNING varchar array), ARRAY[NULL, NULL, NULL]) AS col
+FROM test_array;
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(a_empty, ARRAY['FILLER']) AS col
+FROM test_array;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(json_value(a_nested, '$[5]' RETURNING varchar array), ARRAY['FILLER']) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(json_value(a_nested, '$[7][5]' RETURNING varchar array), ARRAY['FILLER']) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(a_mixed, ARRAY['true', '1', '0.1', 'S1', NULL]) AS col
+FROM test_array;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(json_value(a_nested, '$[6]' RETURNING varchar array), ARRAY['true', '1', '0.1', 'S1', NULL]) AS col
+FROM test_array;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(json_value(a_nested, '$[7][6]' RETURNING varchar array), ARRAY['true', '1', '0.1', 'S1', NULL]) AS col
+FROM test_array;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(a_nested, ARRAY['FILLER']) AS col
+FROM test_array;
+AvaticaSqlException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(json_value(a_nested, '$[7]' RETURNING varchar array), ARRAY['FILLER']) AS col
+FROM test_array;
++----------+
+| col      |
++----------+
+| [FILLER] |
+| [FILLER] |
+| [FILLER] |
+| [FILLER] |
++----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_scalar_funcs TEST_ID: A9_B6_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT nvl(json_value(a_nested, '$[7][7]' RETURNING varchar array), ARRAY['FILLER']) AS col
+FROM test_array;
++----------+
+| col      |
++----------+
+| [FILLER] |
+| [FILLER] |
+| [FILLER] |
+| [FILLER] |
++----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL];
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING count(*) IS NOT NULL;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL];
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING count(*) IS NOT NULL;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL];
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING count(*) IS NOT NULL;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL];
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING count(*) IS NOT NULL;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+WHERE a_null<>ARRAY[NULL,
+                    NULL,
+                    NULL];
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING count(*) IS NOT NULL;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+WHERE a_empty<>ARRAY['FILLER'];
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING count(*) IS NOT NULL;
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
++-----+
+| col |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING count(*)IS NOT NULL;
++-----+
+| col |
++-----+
+|   2 |
+|   2 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B1_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING count(*) IN (4);
++-----+
+| col |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT a_bool) AS col
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL];
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING count(DISTINCT json_value(a_nested, '$[7][0]' RETURNING boolean array)) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT a_int) AS col
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL];
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING count(DISTINCT json_value(a_nested, '$[7][1]' RETURNING bigint array)) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT a_float) AS col
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL];
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING count(DISTINCT json_value(a_nested, '$[7][2]' RETURNING decimal array)) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT a_str) AS col
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL];
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING count(DISTINCT json_value(a_nested, '$[7][3]' RETURNING varchar array)) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT a_null) AS col
+FROM test_array
+WHERE a_null<>ARRAY[NULL,
+                    NULL,
+                    NULL];
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING count(DISTINCT json_value(a_nested, '$[7][4]' RETURNING varchar array)) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT a_empty) AS col
+FROM test_array
+WHERE a_empty<>ARRAY['FILLER'];
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING count(DISTINCT json_value(a_nested, '$[7][5]' RETURNING varchar array)) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT a_mixed) AS col
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
++-----+
+| col |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING count(DISTINCT json_value(a_nested, '$[7][6]' RETURNING varchar array)) IS NOT NULL;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT a_nested) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B2_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING count(DISTINCT json_value(a_nested, '$[7][7]' RETURNING varchar array)) IS NOT NULL;
++-----+
+| col |
++-----+
+|   0 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(a_bool) AS col
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING sum(json_value(a_nested, '$[7][0]' RETURNING boolean array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(a_int) AS col
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING sum(json_value(a_nested, '$[7][1]' RETURNING bigint array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(a_float) AS col
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING sum(json_value(a_nested, '$[7][2]' RETURNING decimal array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(a_str) AS col
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING sum(json_value(a_nested, '$[7][3]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(a_null) AS col
+FROM test_array
+WHERE a_null<>ARRAY[NULL,
+                    NULL,
+                    NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING sum(json_value(a_nested, '$[7][4]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(a_empty) AS col
+FROM test_array
+WHERE a_empty<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING sum(json_value(a_nested, '$[7][5]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(a_mixed) AS col
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING sum(json_value(a_nested, '$[7][6]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(a_nested) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B3_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT sum(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING sum(json_value(a_nested, '$[7][7]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(a_bool) AS col
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL];
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING min(json_value(a_nested, '$[7][0]' RETURNING boolean array)) IS NOT NULL;
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(a_int) AS col
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL];
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING min(json_value(a_nested, '$[7][1]' RETURNING bigint array)) IS NOT NULL;
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(a_float) AS col
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL];
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING min(json_value(a_nested, '$[7][2]' RETURNING decimal array)) IS NOT NULL;
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(a_str) AS col
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL];
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING min(json_value(a_nested, '$[7][3]' RETURNING varchar array)) IS NOT NULL;
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING min(json_value(a_nested, '$[7][4]' RETURNING varchar array)) IS NOT NULL;
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING min(json_value(a_nested, '$[7][5]' RETURNING varchar array)) IS NOT NULL;
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(a_mixed) AS col
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING min(json_value(a_nested, '$[7][6]' RETURNING varchar array)) IS NOT NULL;
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(a_nested) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B4_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT min(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING min(json_value(a_nested, '$[7][7]' RETURNING varchar array)) IS NOT NULL;
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(a_bool) AS col
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL];
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING max(json_value(a_nested, '$[7][0]' RETURNING boolean array)) IS NOT NULL;
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(a_int) AS col
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL];
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING max(json_value(a_nested, '$[7][1]' RETURNING bigint array)) IS NOT NULL;
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(a_float) AS col
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL];
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING max(json_value(a_nested, '$[7][2]' RETURNING decimal array)) IS NOT NULL;
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(a_str) AS col
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL];
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING max(json_value(a_nested, '$[7][3]' RETURNING varchar array)) IS NOT NULL;
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING max(json_value(a_nested, '$[7][4]' RETURNING varchar array)) IS NOT NULL;
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING max(json_value(a_nested, '$[7][5]' RETURNING varchar array)) IS NOT NULL;
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(a_mixed) AS col
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING max(json_value(a_nested, '$[7][6]' RETURNING varchar array)) IS NOT NULL;
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(a_nested) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B5_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT max(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING max(json_value(a_nested, '$[7][7]' RETURNING varchar array)) IS NOT NULL;
+does not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(a_bool) AS col
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING avg(json_value(a_nested, '$[7][0]' RETURNING boolean array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(a_int) AS col
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING avg(json_value(a_nested, '$[7][1]' RETURNING bigint array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(a_float) AS col
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING avg(json_value(a_nested, '$[7][2]' RETURNING decimal array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(a_str) AS col
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING avg(json_value(a_nested, '$[7][3]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(a_null) AS col
+FROM test_array
+WHERE a_null<>ARRAY[NULL,
+                    NULL,
+                    NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING avg(json_value(a_nested, '$[7][4]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(a_empty) AS col
+FROM test_array
+WHERE a_empty<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING avg(json_value(a_nested, '$[7][5]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(a_mixed) AS col
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING avg(json_value(a_nested, '$[7][6]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(a_nested) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B6_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT avg(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING avg(json_value(a_nested, '$[7][7]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(a_bool) AS col
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING approx_count_distinct(json_value(a_nested, '$[7][0]' RETURNING boolean array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(a_int) AS col
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING approx_count_distinct(json_value(a_nested, '$[7][1]' RETURNING bigint array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(a_float) AS col
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING approx_count_distinct(json_value(a_nested, '$[7][2]' RETURNING decimal array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(a_str) AS col
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING approx_count_distinct(json_value(a_nested, '$[7][3]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING approx_count_distinct(json_value(a_nested, '$[7][4]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING approx_count_distinct(json_value(a_nested, '$[7][5]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(a_mixed) AS col
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING approx_count_distinct(json_value(a_nested, '$[7][6]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(a_nested) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B7_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING approx_count_distinct(json_value(a_nested, '$[7][7]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(a_bool) AS col
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING approx_count_distinct_builtin(json_value(a_nested, '$[7][0]' RETURNING boolean array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(a_int) AS col
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING approx_count_distinct_builtin(json_value(a_nested, '$[7][1]' RETURNING bigint array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(a_float) AS col
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING approx_count_distinct_builtin(json_value(a_nested, '$[7][2]' RETURNING decimal array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(a_str) AS col
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING approx_count_distinct_builtin(json_value(a_nested, '$[7][3]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING approx_count_distinct_builtin(json_value(a_nested, '$[7][4]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING approx_count_distinct_builtin(json_value(a_nested, '$[7][5]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(a_mixed) AS col
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING approx_count_distinct_builtin(json_value(a_nested, '$[7][6]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(a_nested) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B8_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT approx_count_distinct_builtin(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING approx_count_distinct_builtin(json_value(a_nested, '$[7][7]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING earliest(json_value(a_nested, '$[7][0]' RETURNING boolean array)) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING earliest(json_value(a_nested, '$[7][1]' RETURNING bigint array)) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING earliest(json_value(a_nested, '$[7][2]' RETURNING decimal array)) IS NOT NULL;
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING earliest(json_value(a_nested, '$[7][3]' RETURNING varchar array)) IS NOT NULL;
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING earliest(json_value(a_nested, '$[7][4]' RETURNING varchar array)) IS NOT NULL;
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING earliest(json_value(a_nested, '$[7][5]' RETURNING varchar array)) IS NOT NULL;
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING earliest(json_value(a_nested, '$[7][6]' RETURNING varchar array)) IS NOT NULL;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(a_nested) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B17_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING earliest(json_value(a_nested, '$[7][7]' RETURNING varchar array)) IS NOT NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[0]' RETURNING boolean array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING earliest(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1000) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[1]' RETURNING bigint array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING earliest(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1000) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[2]' RETURNING decimal array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING earliest(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1000) IS NOT NULL;
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[3]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING earliest(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1000) IS NOT NULL;
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[4]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING earliest(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1000) IS NOT NULL;
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[5]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING earliest(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1000) IS NOT NULL;
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[6]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING earliest(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1000) IS NOT NULL;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(a_nested, 1000) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[7]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B18_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING earliest(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1000) IS NOT NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[0]' RETURNING boolean array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[7][0]' RETURNING boolean array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING earliest_by(json_value(a_nested, '$[7][0]' RETURNING boolean array), time_floor(__time, 'P1D')) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[1]' RETURNING bigint array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[7][1]' RETURNING bigint array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING earliest_by(json_value(a_nested, '$[7][1]' RETURNING bigint array), time_floor(__time, 'P1D')) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[2]' RETURNING decimal array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[7][2]' RETURNING decimal array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING earliest_by(json_value(a_nested, '$[7][2]' RETURNING decimal array), time_floor(__time, 'P1D')) IS NOT NULL;
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[3]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[7][3]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING earliest_by(json_value(a_nested, '$[7][3]' RETURNING varchar array), time_floor(__time, 'P1D')) IS NOT NULL;
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[4]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[7][4]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING earliest_by(json_value(a_nested, '$[7][4]' RETURNING varchar array), time_floor(__time, 'P1D')) IS NOT NULL;
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[5]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[7][5]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING earliest_by(json_value(a_nested, '$[7][5]' RETURNING varchar array), time_floor(__time, 'P1D')) IS NOT NULL;
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[6]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[7][6]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING earliest_by(json_value(a_nested, '$[7][6]' RETURNING varchar array), time_floor(__time, 'P1D')) IS NOT NULL;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(a_nested, time_floor(__time, 'P1D')) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[7]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B19_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[7][7]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING earliest_by(json_value(a_nested, '$[7][7]' RETURNING varchar array), time_floor(__time, 'P1D')) IS NOT NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[0]' RETURNING boolean array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[7][0]' RETURNING boolean array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING earliest_by(json_value(a_nested, '$[7][0]' RETURNING boolean array), time_floor(__time, 'P1D'), 1000) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[1]' RETURNING bigint array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[7][1]' RETURNING bigint array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING earliest_by(json_value(a_nested, '$[7][1]' RETURNING bigint array), time_floor(__time, 'P1D'), 1000) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[2]' RETURNING decimal array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[7][2]' RETURNING decimal array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING earliest_by(json_value(a_nested, '$[7][2]' RETURNING decimal array), time_floor(__time, 'P1D'), 1000) IS NOT NULL;
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[3]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[7][3]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING earliest_by(json_value(a_nested, '$[7][3]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) IS NOT NULL;
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[4]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[7][4]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING earliest_by(json_value(a_nested, '$[7][4]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) IS NOT NULL;
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[5]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[7][5]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING earliest_by(json_value(a_nested, '$[7][5]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) IS NOT NULL;
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[6]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[7][6]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING earliest_by(json_value(a_nested, '$[7][6]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) IS NOT NULL;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(a_nested, time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[7]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B20_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT earliest_by(json_value(a_nested, '$[7][7]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING earliest_by(json_value(a_nested, '$[7][7]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) IS NOT NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING latest(json_value(a_nested, '$[7][0]' RETURNING boolean array)) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING latest(json_value(a_nested, '$[7][1]' RETURNING bigint array)) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING latest(json_value(a_nested, '$[7][2]' RETURNING decimal array)) IS NOT NULL;
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING latest(json_value(a_nested, '$[7][3]' RETURNING varchar array)) IS NOT NULL;
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING latest(json_value(a_nested, '$[7][4]' RETURNING varchar array)) IS NOT NULL;
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING latest(json_value(a_nested, '$[7][5]' RETURNING varchar array)) IS NOT NULL;
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING latest(json_value(a_nested, '$[7][6]' RETURNING varchar array)) IS NOT NULL;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(a_nested) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B21_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING latest(json_value(a_nested, '$[7][7]' RETURNING varchar array)) IS NOT NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[0]' RETURNING boolean array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING latest(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1000) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[1]' RETURNING bigint array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING latest(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1000) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[2]' RETURNING decimal array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING latest(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1000) IS NOT NULL;
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[3]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING latest(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1000) IS NOT NULL;
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[4]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING latest(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1000) IS NOT NULL;
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[5]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING latest(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1000) IS NOT NULL;
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[6]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING latest(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1000) IS NOT NULL;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(a_nested, 1000) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[7]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B22_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING latest(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1000) IS NOT NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[0]' RETURNING boolean array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[7][0]' RETURNING boolean array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING latest_by(json_value(a_nested, '$[7][0]' RETURNING boolean array), time_floor(__time, 'P1D')) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[1]' RETURNING bigint array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[7][1]' RETURNING bigint array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING latest_by(json_value(a_nested, '$[7][1]' RETURNING bigint array), time_floor(__time, 'P1D')) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[2]' RETURNING decimal array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[7][2]' RETURNING decimal array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING latest_by(json_value(a_nested, '$[7][2]' RETURNING decimal array), time_floor(__time, 'P1D')) IS NOT NULL;
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[3]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[7][3]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING latest_by(json_value(a_nested, '$[7][3]' RETURNING varchar array), time_floor(__time, 'P1D')) IS NOT NULL;
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[4]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[7][4]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING latest_by(json_value(a_nested, '$[7][4]' RETURNING varchar array), time_floor(__time, 'P1D')) IS NOT NULL;
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[5]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[7][5]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING latest_by(json_value(a_nested, '$[7][5]' RETURNING varchar array), time_floor(__time, 'P1D')) IS NOT NULL;
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[6]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[7][6]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING latest_by(json_value(a_nested, '$[7][6]' RETURNING varchar array), time_floor(__time, 'P1D')) IS NOT NULL;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(a_nested, time_floor(__time, 'P1D')) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[7]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B23_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[7][7]' RETURNING varchar array), time_floor(__time, 'P1D')) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING latest_by(json_value(a_nested, '$[7][7]' RETURNING varchar array), time_floor(__time, 'P1D')) IS NOT NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[0]' RETURNING boolean array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[7][0]' RETURNING boolean array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING latest_by(json_value(a_nested, '$[7][0]' RETURNING boolean array), time_floor(__time, 'P1D'), 1000) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[1]' RETURNING bigint array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[7][1]' RETURNING bigint array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING latest_by(json_value(a_nested, '$[7][1]' RETURNING bigint array), time_floor(__time, 'P1D'), 1000) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[2]' RETURNING decimal array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[7][2]' RETURNING decimal array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING latest_by(json_value(a_nested, '$[7][2]' RETURNING decimal array), time_floor(__time, 'P1D'), 1000) IS NOT NULL;
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[3]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[7][3]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING latest_by(json_value(a_nested, '$[7][3]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) IS NOT NULL;
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[4]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[7][4]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING latest_by(json_value(a_nested, '$[7][4]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) IS NOT NULL;
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[5]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[7][5]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING latest_by(json_value(a_nested, '$[7][5]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) IS NOT NULL;
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[6]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[7][6]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING latest_by(json_value(a_nested, '$[7][6]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) IS NOT NULL;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(a_nested, time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[7]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B24_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT latest_by(json_value(a_nested, '$[7][7]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING latest_by(json_value(a_nested, '$[7][7]' RETURNING varchar array), time_floor(__time, 'P1D'), 1000) IS NOT NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT any_value(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT any_value(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING any_value(json_value(a_nested, '$[7][0]' RETURNING boolean array)) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT any_value(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT any_value(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING any_value(json_value(a_nested, '$[7][1]' RETURNING bigint array)) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT any_value(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT any_value(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING any_value(json_value(a_nested, '$[7][2]' RETURNING decimal array)) IS NOT NULL;
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT any_value(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT any_value(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING any_value(json_value(a_nested, '$[7][3]' RETURNING varchar array)) IS NOT NULL;
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT any_value(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT any_value(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING any_value(json_value(a_nested, '$[7][4]' RETURNING varchar array)) IS NOT NULL;
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT any_value(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT any_value(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING any_value(json_value(a_nested, '$[7][5]' RETURNING varchar array)) IS NOT NULL;
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT any_value(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT any_value(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING any_value(json_value(a_nested, '$[7][6]' RETURNING varchar array)) IS NOT NULL;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT any_value(a_nested) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT any_value(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B25_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT any_value(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING any_value(json_value(a_nested, '$[7][7]' RETURNING varchar array)) IS NOT NULL;
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool AS col1,
+       grouping(a_bool) AS col
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL];
+may only occur in an aggregate query
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int AS col1,
+       grouping(a_int) AS col
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL];
+may only occur in an aggregate query
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[1]' RETURNING bigint array) AS col1,
+       grouping(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+-----+
+| col1         | col |
++--------------+-----+
+| [1, 2, null] |   0 |
+| [null, 2, 1] |   0 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][1]' RETURNING bigint array) AS col1,
+       grouping(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING grouping(json_value(a_nested, '$[7][1]' RETURNING bigint array)) IS NOT NULL;
++--------------+-----+
+| col1         | col |
++--------------+-----+
+| [1, 2, null] |   0 |
+| [null, 2, 1] |   0 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float AS col1,
+       grouping(a_float) AS col
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL];
+may only occur in an aggregate query
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[2]' RETURNING decimal array) AS col1,
+       grouping(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+-----+
+| col1             | col |
++------------------+-----+
+| [0.1, 0.2, null] |   0 |
+| [null, 0.2, 0.1] |   0 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][2]' RETURNING decimal array) AS col1,
+       grouping(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING grouping(json_value(a_nested, '$[7][2]' RETURNING decimal array)) IS NOT NULL;
++------------------+-----+
+| col1             | col |
++------------------+-----+
+| [0.1, 0.2, null] |   0 |
+| [null, 0.2, 0.1] |   0 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str AS col1,
+       grouping(a_str) AS col
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL];
+may only occur in an aggregate query
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[3]' RETURNING varchar array) AS col1,
+       grouping(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+-----+
+| col1           | col |
++----------------+-----+
+| [S1, S2, null] |   0 |
+| [null, S2, S1] |   0 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][3]' RETURNING varchar array) AS col1,
+       grouping(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING grouping(json_value(a_nested, '$[7][3]' RETURNING varchar array)) IS NOT NULL;
++----------------+-----+
+| col1           | col |
++----------------+-----+
+| [S1, S2, null] |   0 |
+| [null, S2, S1] |   0 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null AS col1,
+       grouping(a_null) AS col
+FROM test_array
+WHERE a_null<>ARRAY[NULL,
+                    NULL,
+                    NULL];
+may only occur in an aggregate query
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[4]' RETURNING varchar array) AS col1,
+       grouping(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
++--------------------+-----+
+| col1               | col |
++--------------------+-----+
+| [null, null, null] |   0 |
++--------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][4]' RETURNING varchar array) AS col1,
+       grouping(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING grouping(json_value(a_nested, '$[7][4]' RETURNING varchar array)) IS NOT NULL;
++--------------------+-----+
+| col1               | col |
++--------------------+-----+
+| [null, null, null] |   0 |
++--------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty AS col1,
+       grouping(a_empty) AS col
+FROM test_array
+WHERE a_empty<>ARRAY['FILLER'];
+may only occur in an aggregate query
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[5]' RETURNING varchar array) AS col1,
+       grouping(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
++------+-----+
+| col1 | col |
++------+-----+
+| []   |   0 |
++------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][5]' RETURNING varchar array) AS col1,
+       grouping(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING grouping(json_value(a_nested, '$[7][5]' RETURNING varchar array)) IS NOT NULL;
++------+-----+
+| col1 | col |
++------+-----+
+| []   |   0 |
++------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed AS col1,
+       grouping(a_mixed) AS col
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
+may only occur in an aggregate query
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[6]' RETURNING varchar array) AS col1,
+       grouping(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+-----+
+| col1                     | col |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   0 |
+| [true, 1, 0.1, S1, null] |   0 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][6]' RETURNING varchar array) AS col1,
+       grouping(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING grouping(json_value(a_nested, '$[7][6]' RETURNING varchar array)) IS NOT NULL;
++--------------------------+-----+
+| col1                     | col |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   0 |
+| [true, 1, 0.1, S1, null] |   0 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested AS col1,
+       grouping(a_nested) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7]' RETURNING varchar array) AS col1,
+       grouping(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
++------+-----+
+| col1 | col |
++------+-----+
+|      |   0 |
++------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B26_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][7]' RETURNING varchar array) AS col1,
+       grouping(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING grouping(json_value(a_nested, '$[7][7]' RETURNING varchar array)) IS NOT NULL;
++------+-----+
+| col1 | col |
++------+-----+
+|      |   0 |
++------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(a_bool) AS col
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL];
++--------------------------+
+| col                      |
++--------------------------+
+| [null, 0, 1, null, 0, 1] |
++--------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(a_int) AS col
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL];
++--------------------------+
+| col                      |
++--------------------------+
+| [null, 2, 1, null, 2, 1] |
++--------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------------------+
+| col                      |
++--------------------------+
+| [1, 2, null, 1, 2, null] |
+| [null, 2, 1, null, 2, 1] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING array_concat_agg(json_value(a_nested, '$[7][1]' RETURNING bigint array)) IS NOT NULL;
++--------------------------+
+| col                      |
++--------------------------+
+| [1, 2, null, 1, 2, null] |
+| [null, 2, 1, null, 2, 1] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(a_float) AS col
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL];
++----------------------------------+
+| col                              |
++----------------------------------+
+| [null, 0.2, 0.1, null, 0.2, 0.1] |
++----------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
++----------------------------------+
+| col                              |
++----------------------------------+
+| [0.1, 0.2, null, 0.1, 0.2, null] |
+| [null, 0.2, 0.1, null, 0.2, 0.1] |
++----------------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING array_concat_agg(json_value(a_nested, '$[7][2]' RETURNING decimal array)) IS NOT NULL;
++----------------------------------+
+| col                              |
++----------------------------------+
+| [0.1, 0.2, null, 0.1, 0.2, null] |
+| [null, 0.2, 0.1, null, 0.2, 0.1] |
++----------------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(a_str) AS col
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL];
++------------------------------+
+| col                          |
++------------------------------+
+| [null, S2, S1, null, S2, S1] |
++------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
++------------------------------+
+| col                          |
++------------------------------+
+| [S1, S2, null, S1, S2, null] |
+| [null, S2, S1, null, S2, S1] |
++------------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING array_concat_agg(json_value(a_nested, '$[7][3]' RETURNING varchar array)) IS NOT NULL;
++------------------------------+
+| col                          |
++------------------------------+
+| [S1, S2, null, S1, S2, null] |
+| [null, S2, S1, null, S2, S1] |
++------------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(a_null) AS col
+FROM test_array
+WHERE a_null<>ARRAY[NULL,
+                    NULL,
+                    NULL];
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
++--------------------------------------------------------------------------+
+| col                                                                      |
++--------------------------------------------------------------------------+
+| [null, null, null, null, null, null, null, null, null, null, null, null] |
++--------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING array_concat_agg(json_value(a_nested, '$[7][4]' RETURNING varchar array)) IS NOT NULL;
++--------------------------------------------------------------------------+
+| col                                                                      |
++--------------------------------------------------------------------------+
+| [null, null, null, null, null, null, null, null, null, null, null, null] |
++--------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(a_empty) AS col
+FROM test_array
+WHERE a_empty<>ARRAY['FILLER'];
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING array_concat_agg(json_value(a_nested, '$[7][5]' RETURNING varchar array)) IS NOT NULL;
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(a_mixed) AS col
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
++--------------------------------------------------+
+| col                                              |
++--------------------------------------------------+
+| [null, S1, 0.1, 1, true, null, S1, 0.1, 1, true] |
++--------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------------------------------+
+| col                                              |
++--------------------------------------------------+
+| [null, S1, 0.1, 1, true, null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null, true, 1, 0.1, S1, null] |
++--------------------------------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING array_concat_agg(json_value(a_nested, '$[7][6]' RETURNING varchar array)) IS NOT NULL;
++--------------------------------------------------+
+| col                                              |
++--------------------------------------------------+
+| [null, S1, 0.1, 1, true, null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null, true, 1, 0.1, S1, null] |
++--------------------------------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(a_nested) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B29_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING array_concat_agg(json_value(a_nested, '$[7][7]' RETURNING varchar array)) IS NOT NULL;
++-----+
+| col |
++-----+
++-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT a_bool) AS col
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL];
++--------------+
+| col          |
++--------------+
+| [null, 0, 1] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT a_int) AS col
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL];
++--------------+
+| col          |
++--------------+
+| [null, 1, 2] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+
+| col          |
++--------------+
+| [null, 1, 2] |
+| [null, 1, 2] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING array_concat_agg(DISTINCT json_value(a_nested, '$[7][1]' RETURNING bigint array)) IS NOT NULL;
++--------------+
+| col          |
++--------------+
+| [null, 1, 2] |
+| [null, 1, 2] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT a_float) AS col
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL];
++------------------+
+| col              |
++------------------+
+| [null, 0.1, 0.2] |
++------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+
+| col              |
++------------------+
+| [null, 0.1, 0.2] |
+| [null, 0.1, 0.2] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING array_concat_agg(DISTINCT json_value(a_nested, '$[7][2]' RETURNING decimal array)) IS NOT NULL;
++------------------+
+| col              |
++------------------+
+| [null, 0.1, 0.2] |
+| [null, 0.1, 0.2] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT a_str) AS col
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL];
++----------------+
+| col            |
++----------------+
+| [null, S1, S2] |
++----------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+
+| col            |
++----------------+
+| [null, S1, S2] |
+| [null, S1, S2] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING array_concat_agg(DISTINCT json_value(a_nested, '$[7][3]' RETURNING varchar array)) IS NOT NULL;
++----------------+
+| col            |
++----------------+
+| [null, S1, S2] |
+| [null, S1, S2] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT a_null) AS col
+FROM test_array
+WHERE a_null<>ARRAY[NULL,
+                    NULL,
+                    NULL];
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
++--------+
+| col    |
++--------+
+| [null] |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING array_concat_agg(DISTINCT json_value(a_nested, '$[7][4]' RETURNING varchar array)) IS NOT NULL;
++--------+
+| col    |
++--------+
+| [null] |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT a_empty) AS col
+FROM test_array
+WHERE a_empty<>ARRAY['FILLER'];
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING array_concat_agg(DISTINCT json_value(a_nested, '$[7][5]' RETURNING varchar array)) IS NOT NULL;
++-----+
+| col |
++-----+
+| []  |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT a_mixed) AS col
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
++--------------------------+
+| col                      |
++--------------------------+
+| [null, 0.1, 1, S1, true] |
++--------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+
+| col                      |
++--------------------------+
+| [null, 0.1, 1, S1, true] |
+| [null, 0.1, 1, S1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING array_concat_agg(DISTINCT json_value(a_nested, '$[7][6]' RETURNING varchar array)) IS NOT NULL;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, 0.1, 1, S1, true] |
+| [null, 0.1, 1, S1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT a_nested) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
++-----+
+| col |
++-----+
+|     |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B30_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat_agg(DISTINCT json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING array_concat_agg(DISTINCT json_value(a_nested, '$[7][7]' RETURNING varchar array)) IS NOT NULL;
++-----+
+| col |
++-----+
++-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(a_bool) AS col
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING bit_and(json_value(a_nested, '$[7][0]' RETURNING boolean array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(a_int) AS col
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING bit_and(json_value(a_nested, '$[7][1]' RETURNING bigint array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(a_float) AS col
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING bit_and(json_value(a_nested, '$[7][2]' RETURNING decimal array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(a_str) AS col
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING bit_and(json_value(a_nested, '$[7][3]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(a_null) AS col
+FROM test_array
+WHERE a_null<>ARRAY[NULL,
+                    NULL,
+                    NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING bit_and(json_value(a_nested, '$[7][4]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(a_empty) AS col
+FROM test_array
+WHERE a_empty<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING bit_and(json_value(a_nested, '$[7][5]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(a_mixed) AS col
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING bit_and(json_value(a_nested, '$[7][6]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(a_nested) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B33_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_and(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING bit_and(json_value(a_nested, '$[7][7]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(a_bool) AS col
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING bit_or(json_value(a_nested, '$[7][0]' RETURNING boolean array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(a_int) AS col
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING bit_or(json_value(a_nested, '$[7][1]' RETURNING bigint array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(a_float) AS col
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING bit_or(json_value(a_nested, '$[7][2]' RETURNING decimal array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(a_str) AS col
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING bit_or(json_value(a_nested, '$[7][3]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(a_null) AS col
+FROM test_array
+WHERE a_null<>ARRAY[NULL,
+                    NULL,
+                    NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING bit_or(json_value(a_nested, '$[7][4]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(a_empty) AS col
+FROM test_array
+WHERE a_empty<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING bit_or(json_value(a_nested, '$[7][5]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(a_mixed) AS col
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING bit_or(json_value(a_nested, '$[7][6]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(a_nested) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B34_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_or(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING bit_or(json_value(a_nested, '$[7][7]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(a_bool) AS col
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING bit_xor(json_value(a_nested, '$[7][0]' RETURNING boolean array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(a_int) AS col
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING bit_xor(json_value(a_nested, '$[7][1]' RETURNING bigint array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(a_float) AS col
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING bit_xor(json_value(a_nested, '$[7][2]' RETURNING decimal array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(a_str) AS col
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING bit_xor(json_value(a_nested, '$[7][3]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(a_null) AS col
+FROM test_array
+WHERE a_null<>ARRAY[NULL,
+                    NULL,
+                    NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING bit_xor(json_value(a_nested, '$[7][4]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(a_empty) AS col
+FROM test_array
+WHERE a_empty<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING bit_xor(json_value(a_nested, '$[7][5]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(a_mixed) AS col
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING bit_xor(json_value(a_nested, '$[7][6]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(a_nested) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_agg_funcs TEST_ID: A1_B35_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT bit_xor(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING bit_xor(json_value(a_nested, '$[7][7]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ARRAY[1,
+             2,
+             NULL] AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ARRAY[0.1,
+             0.2,
+             NULL] AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ARRAY['S1',
+             'S2',
+             NULL] AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ARRAY[] AS col
+FROM test_array;
+Require at least 1 argument
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ARRAY[TRUE,
+             1,
+             0.1,
+             'S1',
+             NULL,[]] AS col
+FROM test_array;
+unexpected token
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ARRAY[TRUE,
+             1,
+             0.1,
+             'S1',
+             NULL] AS col
+FROM test_array;
+Parameters must be of the same type
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT ARRAY['true',
+             '1',
+             '0.1',
+             'S1',
+             'null'] AS col
+FROM test_array;
++--------------------------+
+| col                      |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ARRAY[[1,2,3],
+             [1,2,3]] AS col
+FROM test_array;
+unexpected token
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B1_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT ARRAY[ARRAY[1,
+                   2,
+                   3],ARRAY[1,
+                            2,
+                            3]] AS col
+FROM test_array;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(a_bool) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(a_int) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(a_float) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(a_str) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(a_null) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(a_empty) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(a_mixed) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   5 |
+|   5 |
+|   5 |
+|   5 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   5 |
+|   5 |
+|   5 |
+|   5 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   5 |
+|   5 |
+|   5 |
+|   5 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B2_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(a_bool, 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(json_value(a_nested, '$[0]' RETURNING boolean array), 0) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(json_value(a_nested, '$[7][0]' RETURNING boolean array), 0) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(a_int, 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(json_value(a_nested, '$[1]' RETURNING bigint array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(json_value(a_nested, '$[7][1]' RETURNING bigint array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(a_float, 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(json_value(a_nested, '$[2]' RETURNING decimal array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(json_value(a_nested, '$[7][2]' RETURNING decimal array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(a_str, 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| S1  |
+| S1  |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(json_value(a_nested, '$[3]' RETURNING varchar array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| S1  |
+| S1  |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(json_value(a_nested, '$[7][3]' RETURNING varchar array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| S1  |
+| S1  |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(a_null, 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(json_value(a_nested, '$[4]' RETURNING varchar array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(json_value(a_nested, '$[7][4]' RETURNING varchar array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(a_empty, 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(json_value(a_nested, '$[5]' RETURNING varchar array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(json_value(a_nested, '$[7][5]' RETURNING varchar array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(a_mixed, 0) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(json_value(a_nested, '$[6]' RETURNING varchar array), 0) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(json_value(a_nested, '$[7][6]' RETURNING varchar array), 0) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(a_nested, 0) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(json_value(a_nested, '$[7]' RETURNING varchar array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B3_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset(json_value(a_nested, '$[7][7]' RETURNING varchar array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(a_bool, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(a_int, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(a_float, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(a_str, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| S1  |
+| S1  |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| S1  |
+| S1  |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| S1  |
+| S1  |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(a_null, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(a_empty, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(a_mixed, 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B4_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(a_bool, 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(a_int, 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(a_float, 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(a_str, 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(a_null, 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(a_empty, 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(a_mixed, 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B5_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_contains(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(a_bool, ARRAY[1]) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(json_value(a_nested, '$[0]' RETURNING boolean array), ARRAY[1]) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(json_value(a_nested, '$[7][0]' RETURNING boolean array), ARRAY[1]) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(a_int, ARRAY[1]) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(json_value(a_nested, '$[1]' RETURNING bigint array), ARRAY[1]) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(json_value(a_nested, '$[7][1]' RETURNING bigint array), ARRAY[1]) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(a_float, ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(json_value(a_nested, '$[2]' RETURNING decimal array), ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(json_value(a_nested, '$[7][2]' RETURNING decimal array), ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(a_str, ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(json_value(a_nested, '$[3]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(json_value(a_nested, '$[7][3]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(a_null, ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(json_value(a_nested, '$[4]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(json_value(a_nested, '$[7][4]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(a_empty, ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(json_value(a_nested, '$[5]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(json_value(a_nested, '$[7][5]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(a_mixed, ARRAY[1]) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(json_value(a_nested, '$[6]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(json_value(a_nested, '$[7][6]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(a_nested, ARRAY[1]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(json_value(a_nested, '$[7]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B6_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_overlap(json_value(a_nested, '$[7][7]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(a_bool, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(a_int, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(a_float, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(a_str, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(a_null, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(a_empty, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(a_mixed, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B7_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_offset_of(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(a_bool, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(a_int, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(a_float, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(a_str, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(a_null, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(a_empty, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(a_mixed, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B8_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_ordinal_of(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, a_bool) AS col
+FROM test_array;
++-----------------+
+| col             |
++-----------------+
+| [9, 1, 0, null] |
+| [9, 1, 0, null] |
+| [9, null, 0, 1] |
+| [9, null, 0, 1] |
++-----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, a_int) AS col
+FROM test_array;
++-----------------+
+| col             |
++-----------------+
+| [9, 1, 2, null] |
+| [9, 1, 2, null] |
+| [9, null, 2, 1] |
+| [9, null, 2, 1] |
++-----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
++-----------------+
+| col             |
++-----------------+
+| [9, 1, 2, null] |
+| [9, 1, 2, null] |
+| [9, null, 2, 1] |
+| [9, null, 2, 1] |
++-----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
++-----------------+
+| col             |
++-----------------+
+| [9, 1, 2, null] |
+| [9, 1, 2, null] |
+| [9, null, 2, 1] |
+| [9, null, 2, 1] |
++-----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, a_float) AS col
+FROM test_array;
++-----------------------+
+| col                   |
++-----------------------+
+| [9.0, 0.1, 0.2, null] |
+| [9.0, 0.1, 0.2, null] |
+| [9.0, null, 0.2, 0.1] |
+| [9.0, null, 0.2, 0.1] |
++-----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
++-----------------------+
+| col                   |
++-----------------------+
+| [9.0, 0.1, 0.2, null] |
+| [9.0, 0.1, 0.2, null] |
+| [9.0, null, 0.2, 0.1] |
+| [9.0, null, 0.2, 0.1] |
++-----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
++-----------------------+
+| col                   |
++-----------------------+
+| [9.0, 0.1, 0.2, null] |
+| [9.0, 0.1, 0.2, null] |
+| [9.0, null, 0.2, 0.1] |
+| [9.0, null, 0.2, 0.1] |
++-----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, a_str) AS col
+FROM test_array;
++-------------------+
+| col               |
++-------------------+
+| [9, S1, S2, null] |
+| [9, S1, S2, null] |
+| [9, null, S2, S1] |
+| [9, null, S2, S1] |
++-------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
++-------------------+
+| col               |
++-------------------+
+| [9, S1, S2, null] |
+| [9, S1, S2, null] |
+| [9, null, S2, S1] |
+| [9, null, S2, S1] |
++-------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
++-------------------+
+| col               |
++-------------------+
+| [9, S1, S2, null] |
+| [9, S1, S2, null] |
+| [9, null, S2, S1] |
+| [9, null, S2, S1] |
++-------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, a_null) AS col
+FROM test_array;
++-----------------------+
+| col                   |
++-----------------------+
+| [9, null, null, null] |
+| [9, null, null, null] |
+| [9, null, null, null] |
+| [9, null, null, null] |
++-----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
++-----------------------+
+| col                   |
++-----------------------+
+| [9, null, null, null] |
+| [9, null, null, null] |
+| [9, null, null, null] |
+| [9, null, null, null] |
++-----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
++-----------------------+
+| col                   |
++-----------------------+
+| [9, null, null, null] |
+| [9, null, null, null] |
+| [9, null, null, null] |
+| [9, null, null, null] |
++-----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, a_empty) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [9] |
+| [9] |
+| [9] |
+| [9] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [9] |
+| [9] |
+| [9] |
+| [9] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [9] |
+| [9] |
+| [9] |
+| [9] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, a_mixed) AS col
+FROM test_array;
++-----------------------------+
+| col                         |
++-----------------------------+
+| [9, null, S1, 0.1, 1, true] |
+| [9, null, S1, 0.1, 1, true] |
+| [9, true, 1, 0.1, S1, null] |
+| [9, true, 1, 0.1, S1, null] |
++-----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
++-----------------------------+
+| col                         |
++-----------------------------+
+| [9, null, S1, 0.1, 1, true] |
+| [9, null, S1, 0.1, 1, true] |
+| [9, true, 1, 0.1, S1, null] |
+| [9, true, 1, 0.1, S1, null] |
++-----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
++-----------------------------+
+| col                         |
++-----------------------------+
+| [9, null, S1, 0.1, 1, true] |
+| [9, null, S1, 0.1, 1, true] |
+| [9, true, 1, 0.1, S1, null] |
+| [9, true, 1, 0.1, S1, null] |
++-----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B9_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_prepend(9, json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(a_bool, 9) AS col
+FROM test_array;
++-----------------+
+| col             |
++-----------------+
+| [1, 0, null, 9] |
+| [1, 0, null, 9] |
+| [null, 0, 1, 9] |
+| [null, 0, 1, 9] |
++-----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(a_int, 9) AS col
+FROM test_array;
++-----------------+
+| col             |
++-----------------+
+| [1, 2, null, 9] |
+| [1, 2, null, 9] |
+| [null, 2, 1, 9] |
+| [null, 2, 1, 9] |
++-----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(json_value(a_nested, '$[1]' RETURNING bigint array), 9) AS col
+FROM test_array;
++-----------------+
+| col             |
++-----------------+
+| [1, 2, null, 9] |
+| [1, 2, null, 9] |
+| [null, 2, 1, 9] |
+| [null, 2, 1, 9] |
++-----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(json_value(a_nested, '$[7][1]' RETURNING bigint array), 9) AS col
+FROM test_array;
++-----------------+
+| col             |
++-----------------+
+| [1, 2, null, 9] |
+| [1, 2, null, 9] |
+| [null, 2, 1, 9] |
+| [null, 2, 1, 9] |
++-----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(a_float, 9) AS col
+FROM test_array;
++-----------------------+
+| col                   |
++-----------------------+
+| [0.1, 0.2, null, 9.0] |
+| [0.1, 0.2, null, 9.0] |
+| [null, 0.2, 0.1, 9.0] |
+| [null, 0.2, 0.1, 9.0] |
++-----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(json_value(a_nested, '$[2]' RETURNING decimal array), 9) AS col
+FROM test_array;
++-----------------------+
+| col                   |
++-----------------------+
+| [0.1, 0.2, null, 9.0] |
+| [0.1, 0.2, null, 9.0] |
+| [null, 0.2, 0.1, 9.0] |
+| [null, 0.2, 0.1, 9.0] |
++-----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(json_value(a_nested, '$[7][2]' RETURNING decimal array), 9) AS col
+FROM test_array;
++-----------------------+
+| col                   |
++-----------------------+
+| [0.1, 0.2, null, 9.0] |
+| [0.1, 0.2, null, 9.0] |
+| [null, 0.2, 0.1, 9.0] |
+| [null, 0.2, 0.1, 9.0] |
++-----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(a_str, 9) AS col
+FROM test_array;
++-------------------+
+| col               |
++-------------------+
+| [S1, S2, null, 9] |
+| [S1, S2, null, 9] |
+| [null, S2, S1, 9] |
+| [null, S2, S1, 9] |
++-------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(json_value(a_nested, '$[3]' RETURNING varchar array), 9) AS col
+FROM test_array;
++-------------------+
+| col               |
++-------------------+
+| [S1, S2, null, 9] |
+| [S1, S2, null, 9] |
+| [null, S2, S1, 9] |
+| [null, S2, S1, 9] |
++-------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(json_value(a_nested, '$[7][3]' RETURNING varchar array), 9) AS col
+FROM test_array;
++-------------------+
+| col               |
++-------------------+
+| [S1, S2, null, 9] |
+| [S1, S2, null, 9] |
+| [null, S2, S1, 9] |
+| [null, S2, S1, 9] |
++-------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(a_null, 9) AS col
+FROM test_array;
++-----------------------+
+| col                   |
++-----------------------+
+| [null, null, null, 9] |
+| [null, null, null, 9] |
+| [null, null, null, 9] |
+| [null, null, null, 9] |
++-----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(json_value(a_nested, '$[4]' RETURNING varchar array), 9) AS col
+FROM test_array;
++-----------------------+
+| col                   |
++-----------------------+
+| [null, null, null, 9] |
+| [null, null, null, 9] |
+| [null, null, null, 9] |
+| [null, null, null, 9] |
++-----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(json_value(a_nested, '$[7][4]' RETURNING varchar array), 9) AS col
+FROM test_array;
++-----------------------+
+| col                   |
++-----------------------+
+| [null, null, null, 9] |
+| [null, null, null, 9] |
+| [null, null, null, 9] |
+| [null, null, null, 9] |
++-----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(a_empty, 9) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [9] |
+| [9] |
+| [9] |
+| [9] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(json_value(a_nested, '$[5]' RETURNING varchar array), 9) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [9] |
+| [9] |
+| [9] |
+| [9] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(json_value(a_nested, '$[7][5]' RETURNING varchar array), 9) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [9] |
+| [9] |
+| [9] |
+| [9] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(a_mixed, 9) AS col
+FROM test_array;
++-----------------------------+
+| col                         |
++-----------------------------+
+| [null, S1, 0.1, 1, true, 9] |
+| [null, S1, 0.1, 1, true, 9] |
+| [true, 1, 0.1, S1, null, 9] |
+| [true, 1, 0.1, S1, null, 9] |
++-----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(json_value(a_nested, '$[6]' RETURNING varchar array), 9) AS col
+FROM test_array;
++-----------------------------+
+| col                         |
++-----------------------------+
+| [null, S1, 0.1, 1, true, 9] |
+| [null, S1, 0.1, 1, true, 9] |
+| [true, 1, 0.1, S1, null, 9] |
+| [true, 1, 0.1, S1, null, 9] |
++-----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(json_value(a_nested, '$[7][6]' RETURNING varchar array), 9) AS col
+FROM test_array;
++-----------------------------+
+| col                         |
++-----------------------------+
+| [null, S1, 0.1, 1, true, 9] |
+| [null, S1, 0.1, 1, true, 9] |
+| [true, 1, 0.1, S1, null, 9] |
+| [true, 1, 0.1, S1, null, 9] |
++-----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(a_nested, 9) AS col
+FROM test_array;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(json_value(a_nested, '$[7]' RETURNING varchar array), 9) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B10_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_append(json_value(a_nested, '$[7][7]' RETURNING varchar array), 9) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(a_bool, a_bool) AS col
+FROM test_array;
++--------------------------+
+| col                      |
++--------------------------+
+| [1, 0, null, 1, 0, null] |
+| [1, 0, null, 1, 0, null] |
+| [null, 0, 1, null, 0, 1] |
+| [null, 0, 1, null, 0, 1] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(a_int, a_int) AS col
+FROM test_array;
++--------------------------+
+| col                      |
++--------------------------+
+| [1, 2, null, 1, 2, null] |
+| [1, 2, null, 1, 2, null] |
+| [null, 2, 1, null, 2, 1] |
+| [null, 2, 1, null, 2, 1] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(json_value(a_nested, '$[1]' RETURNING bigint array), json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
++--------------------------+
+| col                      |
++--------------------------+
+| [1, 2, null, 1, 2, null] |
+| [1, 2, null, 1, 2, null] |
+| [null, 2, 1, null, 2, 1] |
+| [null, 2, 1, null, 2, 1] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(json_value(a_nested, '$[7][1]' RETURNING bigint array), json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
++--------------------------+
+| col                      |
++--------------------------+
+| [1, 2, null, 1, 2, null] |
+| [1, 2, null, 1, 2, null] |
+| [null, 2, 1, null, 2, 1] |
+| [null, 2, 1, null, 2, 1] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(a_float, a_float) AS col
+FROM test_array;
++----------------------------------+
+| col                              |
++----------------------------------+
+| [0.1, 0.2, null, 0.1, 0.2, null] |
+| [0.1, 0.2, null, 0.1, 0.2, null] |
+| [null, 0.2, 0.1, null, 0.2, 0.1] |
+| [null, 0.2, 0.1, null, 0.2, 0.1] |
++----------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(json_value(a_nested, '$[2]' RETURNING decimal array), json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
++----------------------------------+
+| col                              |
++----------------------------------+
+| [0.1, 0.2, null, 0.1, 0.2, null] |
+| [0.1, 0.2, null, 0.1, 0.2, null] |
+| [null, 0.2, 0.1, null, 0.2, 0.1] |
+| [null, 0.2, 0.1, null, 0.2, 0.1] |
++----------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(json_value(a_nested, '$[7][2]' RETURNING decimal array), json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
++----------------------------------+
+| col                              |
++----------------------------------+
+| [0.1, 0.2, null, 0.1, 0.2, null] |
+| [0.1, 0.2, null, 0.1, 0.2, null] |
+| [null, 0.2, 0.1, null, 0.2, 0.1] |
+| [null, 0.2, 0.1, null, 0.2, 0.1] |
++----------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(a_str, a_str) AS col
+FROM test_array;
++------------------------------+
+| col                          |
++------------------------------+
+| [S1, S2, null, S1, S2, null] |
+| [S1, S2, null, S1, S2, null] |
+| [null, S2, S1, null, S2, S1] |
+| [null, S2, S1, null, S2, S1] |
++------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(json_value(a_nested, '$[3]' RETURNING varchar array), json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------------------+
+| col                          |
++------------------------------+
+| [S1, S2, null, S1, S2, null] |
+| [S1, S2, null, S1, S2, null] |
+| [null, S2, S1, null, S2, S1] |
+| [null, S2, S1, null, S2, S1] |
++------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(json_value(a_nested, '$[7][3]' RETURNING varchar array), json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------------------+
+| col                          |
++------------------------------+
+| [S1, S2, null, S1, S2, null] |
+| [S1, S2, null, S1, S2, null] |
+| [null, S2, S1, null, S2, S1] |
+| [null, S2, S1, null, S2, S1] |
++------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(a_null, a_null) AS col
+FROM test_array;
++--------------------------------------+
+| col                                  |
++--------------------------------------+
+| [null, null, null, null, null, null] |
+| [null, null, null, null, null, null] |
+| [null, null, null, null, null, null] |
+| [null, null, null, null, null, null] |
++--------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(json_value(a_nested, '$[4]' RETURNING varchar array), json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
++--------------------------------------+
+| col                                  |
++--------------------------------------+
+| [null, null, null, null, null, null] |
+| [null, null, null, null, null, null] |
+| [null, null, null, null, null, null] |
+| [null, null, null, null, null, null] |
++--------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(json_value(a_nested, '$[7][4]' RETURNING varchar array), json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
++--------------------------------------+
+| col                                  |
++--------------------------------------+
+| [null, null, null, null, null, null] |
+| [null, null, null, null, null, null] |
+| [null, null, null, null, null, null] |
+| [null, null, null, null, null, null] |
++--------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(a_empty, a_empty) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(json_value(a_nested, '$[5]' RETURNING varchar array), json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(json_value(a_nested, '$[7][5]' RETURNING varchar array), json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(a_mixed, a_mixed) AS col
+FROM test_array;
++--------------------------------------------------+
+| col                                              |
++--------------------------------------------------+
+| [null, S1, 0.1, 1, true, null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true, null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null, true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null, true, 1, 0.1, S1, null] |
++--------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(json_value(a_nested, '$[6]' RETURNING varchar array), json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
++--------------------------------------------------+
+| col                                              |
++--------------------------------------------------+
+| [null, S1, 0.1, 1, true, null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true, null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null, true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null, true, 1, 0.1, S1, null] |
++--------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(json_value(a_nested, '$[7][6]' RETURNING varchar array), json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
++--------------------------------------------------+
+| col                                              |
++--------------------------------------------------+
+| [null, S1, 0.1, 1, true, null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true, null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null, true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null, true, 1, 0.1, S1, null] |
++--------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(a_nested, a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(json_value(a_nested, '$[7]' RETURNING varchar array), json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B11_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_concat(json_value(a_nested, '$[7][7]' RETURNING varchar array), json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(a_bool, 0, 2) AS col
+FROM test_array;
++-----------+
+| col       |
++-----------+
+| [1, 0]    |
+| [1, 0]    |
+| [null, 0] |
+| [null, 0] |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(a_int, 0, 2) AS col
+FROM test_array;
++-----------+
+| col       |
++-----------+
+| [1, 2]    |
+| [1, 2]    |
+| [null, 2] |
+| [null, 2] |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(json_value(a_nested, '$[1]' RETURNING bigint array), 0, 2) AS col
+FROM test_array;
++-----------+
+| col       |
++-----------+
+| [1, 2]    |
+| [1, 2]    |
+| [null, 2] |
+| [null, 2] |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(json_value(a_nested, '$[7][1]' RETURNING bigint array), 0, 2) AS col
+FROM test_array;
++-----------+
+| col       |
++-----------+
+| [1, 2]    |
+| [1, 2]    |
+| [null, 2] |
+| [null, 2] |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(a_float, 0, 2) AS col
+FROM test_array;
++-------------+
+| col         |
++-------------+
+| [0.1, 0.2]  |
+| [0.1, 0.2]  |
+| [null, 0.2] |
+| [null, 0.2] |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(json_value(a_nested, '$[2]' RETURNING decimal array), 0, 2) AS col
+FROM test_array;
++-------------+
+| col         |
++-------------+
+| [0.1, 0.2]  |
+| [0.1, 0.2]  |
+| [null, 0.2] |
+| [null, 0.2] |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(json_value(a_nested, '$[7][2]' RETURNING decimal array), 0, 2) AS col
+FROM test_array;
++-------------+
+| col         |
++-------------+
+| [0.1, 0.2]  |
+| [0.1, 0.2]  |
+| [null, 0.2] |
+| [null, 0.2] |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(a_str, 0, 2) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| [S1, S2]   |
+| [S1, S2]   |
+| [null, S2] |
+| [null, S2] |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(json_value(a_nested, '$[3]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| [S1, S2]   |
+| [S1, S2]   |
+| [null, S2] |
+| [null, S2] |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(json_value(a_nested, '$[7][3]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| [S1, S2]   |
+| [S1, S2]   |
+| [null, S2] |
+| [null, S2] |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(a_null, 0, 2) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [null, null] |
+| [null, null] |
+| [null, null] |
+| [null, null] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(json_value(a_nested, '$[4]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [null, null] |
+| [null, null] |
+| [null, null] |
+| [null, null] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(json_value(a_nested, '$[7][4]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [null, null] |
+| [null, null] |
+| [null, null] |
+| [null, null] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(a_empty, 0, 2) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [null, null] |
+| [null, null] |
+| [null, null] |
+| [null, null] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(json_value(a_nested, '$[5]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [null, null] |
+| [null, null] |
+| [null, null] |
+| [null, null] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(json_value(a_nested, '$[7][5]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [null, null] |
+| [null, null] |
+| [null, null] |
+| [null, null] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(a_mixed, 0, 2) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| [null, S1] |
+| [null, S1] |
+| [true, 1]  |
+| [true, 1]  |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(json_value(a_nested, '$[6]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| [null, S1] |
+| [null, S1] |
+| [true, 1]  |
+| [true, 1]  |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(json_value(a_nested, '$[7][6]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| [null, S1] |
+| [null, S1] |
+| [true, 1]  |
+| [true, 1]  |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(a_nested, 0, 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(json_value(a_nested, '$[7]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B12_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_slice(json_value(a_nested, '$[7][7]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(a_bool, '|') AS col
+FROM test_array;
++----------+
+| col      |
++----------+
+| 1|0|null |
+| 1|0|null |
+| null|0|1 |
+| null|0|1 |
++----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(json_value(a_nested, '$[0]' RETURNING boolean array), '|') AS col
+FROM test_array;
++----------+
+| col      |
++----------+
+| 1|0|null |
+| 1|0|null |
+| null|0|1 |
+| null|0|1 |
++----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(json_value(a_nested, '$[7][0]' RETURNING boolean array), '|') AS col
+FROM test_array;
++----------+
+| col      |
++----------+
+| 1|0|null |
+| 1|0|null |
+| null|0|1 |
+| null|0|1 |
++----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(a_int, '|') AS col
+FROM test_array;
++----------+
+| col      |
++----------+
+| 1|2|null |
+| 1|2|null |
+| null|2|1 |
+| null|2|1 |
++----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(json_value(a_nested, '$[1]' RETURNING bigint array), '|') AS col
+FROM test_array;
++----------+
+| col      |
++----------+
+| 1|2|null |
+| 1|2|null |
+| null|2|1 |
+| null|2|1 |
++----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(json_value(a_nested, '$[7][1]' RETURNING bigint array), '|') AS col
+FROM test_array;
++----------+
+| col      |
++----------+
+| 1|2|null |
+| 1|2|null |
+| null|2|1 |
+| null|2|1 |
++----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(a_float, '|') AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| 0.1|0.2|null |
+| 0.1|0.2|null |
+| null|0.2|0.1 |
+| null|0.2|0.1 |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(json_value(a_nested, '$[2]' RETURNING decimal array), '|') AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| 0.1|0.2|null |
+| 0.1|0.2|null |
+| null|0.2|0.1 |
+| null|0.2|0.1 |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(json_value(a_nested, '$[7][2]' RETURNING decimal array), '|') AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| 0.1|0.2|null |
+| 0.1|0.2|null |
+| null|0.2|0.1 |
+| null|0.2|0.1 |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(a_str, '|') AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| S1|S2|null |
+| S1|S2|null |
+| null|S2|S1 |
+| null|S2|S1 |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(json_value(a_nested, '$[3]' RETURNING varchar array), '|') AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| S1|S2|null |
+| S1|S2|null |
+| null|S2|S1 |
+| null|S2|S1 |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(json_value(a_nested, '$[7][3]' RETURNING varchar array), '|') AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| S1|S2|null |
+| S1|S2|null |
+| null|S2|S1 |
+| null|S2|S1 |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(a_null, '|') AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| null|null|null |
+| null|null|null |
+| null|null|null |
+| null|null|null |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(json_value(a_nested, '$[4]' RETURNING varchar array), '|') AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| null|null|null |
+| null|null|null |
+| null|null|null |
+| null|null|null |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(json_value(a_nested, '$[7][4]' RETURNING varchar array), '|') AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| null|null|null |
+| null|null|null |
+| null|null|null |
+| null|null|null |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(a_empty, '|') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(json_value(a_nested, '$[5]' RETURNING varchar array), '|') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(json_value(a_nested, '$[7][5]' RETURNING varchar array), '|') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(a_mixed, '|') AS col
+FROM test_array;
++--------------------+
+| col                |
++--------------------+
+| null|S1|0.1|1|true |
+| null|S1|0.1|1|true |
+| true|1|0.1|S1|null |
+| true|1|0.1|S1|null |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(json_value(a_nested, '$[6]' RETURNING varchar array), '|') AS col
+FROM test_array;
++--------------------+
+| col                |
++--------------------+
+| null|S1|0.1|1|true |
+| null|S1|0.1|1|true |
+| true|1|0.1|S1|null |
+| true|1|0.1|S1|null |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(json_value(a_nested, '$[7][6]' RETURNING varchar array), '|') AS col
+FROM test_array;
++--------------------+
+| col                |
++--------------------+
+| null|S1|0.1|1|true |
+| null|S1|0.1|1|true |
+| true|1|0.1|S1|null |
+| true|1|0.1|S1|null |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(a_nested, '|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(json_value(a_nested, '$[7]' RETURNING varchar array), '|') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B13_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_string(json_value(a_nested, '$[7][7]' RETURNING varchar array), '|') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C0_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array('true|1|0.1|S1|null', '\|') AS col
+FROM test_array;
++--------------------------+
+| col                      |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(a_bool, '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(json_value(a_nested, '$[0]' RETURNING boolean array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(json_value(a_nested, '$[7][0]' RETURNING boolean array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(a_int, '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(json_value(a_nested, '$[1]' RETURNING bigint array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(json_value(a_nested, '$[7][1]' RETURNING bigint array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(a_float, '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(json_value(a_nested, '$[2]' RETURNING decimal array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(json_value(a_nested, '$[7][2]' RETURNING decimal array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(a_str, '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(json_value(a_nested, '$[3]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(json_value(a_nested, '$[7][3]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(a_null, '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(json_value(a_nested, '$[4]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(json_value(a_nested, '$[7][4]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(a_empty, '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(json_value(a_nested, '$[5]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(json_value(a_nested, '$[7][5]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(a_mixed, '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(json_value(a_nested, '$[6]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(json_value(a_nested, '$[7][6]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(a_nested, '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(json_value(a_nested, '$[7]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B14_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_array(json_value(a_nested, '$[7][7]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(a_bool) AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| ["1","0",null] |
+| ["1","0",null] |
+| [null,"0","1"] |
+| [null,"0","1"] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| ["1","0",null] |
+| ["1","0",null] |
+| [null,"0","1"] |
+| [null,"0","1"] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| ["1","0",null] |
+| ["1","0",null] |
+| [null,"0","1"] |
+| [null,"0","1"] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(a_int) AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| ["1","2",null] |
+| ["1","2",null] |
+| [null,"2","1"] |
+| [null,"2","1"] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| ["1","2",null] |
+| ["1","2",null] |
+| [null,"2","1"] |
+| [null,"2","1"] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| ["1","2",null] |
+| ["1","2",null] |
+| [null,"2","1"] |
+| [null,"2","1"] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(a_float) AS col
+FROM test_array;
++--------------------+
+| col                |
++--------------------+
+| ["0.1","0.2",null] |
+| ["0.1","0.2",null] |
+| [null,"0.2","0.1"] |
+| [null,"0.2","0.1"] |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
++--------------------+
+| col                |
++--------------------+
+| ["0.1","0.2",null] |
+| ["0.1","0.2",null] |
+| [null,"0.2","0.1"] |
+| [null,"0.2","0.1"] |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
++--------------------+
+| col                |
++--------------------+
+| ["0.1","0.2",null] |
+| ["0.1","0.2",null] |
+| [null,"0.2","0.1"] |
+| [null,"0.2","0.1"] |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(a_str) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| ["S1","S2",null] |
+| ["S1","S2",null] |
+| [null,"S2","S1"] |
+| [null,"S2","S1"] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| ["S1","S2",null] |
+| ["S1","S2",null] |
+| [null,"S2","S1"] |
+| [null,"S2","S1"] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| ["S1","S2",null] |
+| ["S1","S2",null] |
+| [null,"S2","S1"] |
+| [null,"S2","S1"] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(a_null) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| [null,null,null] |
+| [null,null,null] |
+| [null,null,null] |
+| [null,null,null] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| [null,null,null] |
+| [null,null,null] |
+| [null,null,null] |
+| [null,null,null] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| [null,null,null] |
+| [null,null,null] |
+| [null,null,null] |
+| [null,null,null] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(a_empty) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(a_mixed) AS col
+FROM test_array;
++------------------------------+
+| col                          |
++------------------------------+
+| ["true","1","0.1","S1",null] |
+| ["true","1","0.1","S1",null] |
+| [null,"S1","0.1","1","true"] |
+| [null,"S1","0.1","1","true"] |
++------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------------------+
+| col                          |
++------------------------------+
+| ["true","1","0.1","S1",null] |
+| ["true","1","0.1","S1",null] |
+| [null,"S1","0.1","1","true"] |
+| [null,"S1","0.1","1","true"] |
++------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------------------+
+| col                          |
++------------------------------+
+| ["true","1","0.1","S1",null] |
+| ["true","1","0.1","S1",null] |
+| [null,"S1","0.1","1","true"] |
+| [null,"S1","0.1","1","true"] |
++------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_array_funcs TEST_ID: A1_B15_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_to_mv(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(a_bool, ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(json_value(a_nested, '$[0]' RETURNING boolean array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(json_value(a_nested, '$[7][0]' RETURNING boolean array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(a_int, ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(json_value(a_nested, '$[1]' RETURNING bigint array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(json_value(a_nested, '$[7][1]' RETURNING bigint array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(a_float, ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(json_value(a_nested, '$[2]' RETURNING decimal array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(json_value(a_nested, '$[7][2]' RETURNING decimal array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(a_str, ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(json_value(a_nested, '$[3]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(json_value(a_nested, '$[7][3]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(a_null, ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(json_value(a_nested, '$[4]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(json_value(a_nested, '$[7][4]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(a_empty, ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(json_value(a_nested, '$[5]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(json_value(a_nested, '$[7][5]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(a_mixed, ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(json_value(a_nested, '$[6]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(json_value(a_nested, '$[7][6]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(a_nested, ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(json_value(a_nested, '$[7]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B1_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_only(json_value(a_nested, '$[7][7]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(a_bool, ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(json_value(a_nested, '$[0]' RETURNING boolean array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(json_value(a_nested, '$[7][0]' RETURNING boolean array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(a_int, ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(json_value(a_nested, '$[1]' RETURNING bigint array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(json_value(a_nested, '$[7][1]' RETURNING bigint array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(a_float, ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(json_value(a_nested, '$[2]' RETURNING decimal array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(json_value(a_nested, '$[7][2]' RETURNING decimal array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(a_str, ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(json_value(a_nested, '$[3]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(json_value(a_nested, '$[7][3]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(a_null, ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(json_value(a_nested, '$[4]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(json_value(a_nested, '$[7][4]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(a_empty, ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(json_value(a_nested, '$[5]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(json_value(a_nested, '$[7][5]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(a_mixed, ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(json_value(a_nested, '$[6]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(json_value(a_nested, '$[7][6]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(a_nested, ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(json_value(a_nested, '$[7]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B2_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_filter_none(json_value(a_nested, '$[7][7]' RETURNING varchar array), ARRAY[1, 2]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(a_bool) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(a_int) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(a_float) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(a_str) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(a_null) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   3 |
+|   3 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(a_empty) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   0 |
+|   0 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(a_mixed) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   5 |
+|   5 |
+|   5 |
+|   5 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   5 |
+|   5 |
+|   5 |
+|   5 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   5 |
+|   5 |
+|   5 |
+|   5 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B3_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_length(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(a_bool, 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(json_value(a_nested, '$[0]' RETURNING boolean array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(json_value(a_nested, '$[7][0]' RETURNING boolean array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(a_int, 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(json_value(a_nested, '$[1]' RETURNING bigint array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(json_value(a_nested, '$[7][1]' RETURNING bigint array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(a_float, 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(json_value(a_nested, '$[2]' RETURNING decimal array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(json_value(a_nested, '$[7][2]' RETURNING decimal array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(a_str, 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| S1  |
+| S1  |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(json_value(a_nested, '$[3]' RETURNING varchar array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| S1  |
+| S1  |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(json_value(a_nested, '$[7][3]' RETURNING varchar array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| S1  |
+| S1  |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(a_null, 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(json_value(a_nested, '$[4]' RETURNING varchar array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(json_value(a_nested, '$[7][4]' RETURNING varchar array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(a_empty, 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(json_value(a_nested, '$[5]' RETURNING varchar array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(json_value(a_nested, '$[7][5]' RETURNING varchar array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(a_mixed, 0) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(json_value(a_nested, '$[6]' RETURNING varchar array), 0) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(json_value(a_nested, '$[7][6]' RETURNING varchar array), 0) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(a_nested, 0) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(json_value(a_nested, '$[7]' RETURNING varchar array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B4_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset(json_value(a_nested, '$[7][7]' RETURNING varchar array), 0) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(a_bool, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(a_int, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(a_float, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(a_str, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| S1  |
+| S1  |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| S1  |
+| S1  |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| S1  |
+| S1  |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(a_null, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(a_empty, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(a_mixed, 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B5_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(a_bool, 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(a_int, 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(a_float, 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(a_str, 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(a_null, 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(a_empty, 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(a_mixed, 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B6_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_contains(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(a_bool, ARRAY[1]) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(json_value(a_nested, '$[0]' RETURNING boolean array), ARRAY[1]) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(json_value(a_nested, '$[7][0]' RETURNING boolean array), ARRAY[1]) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(a_int, ARRAY[1]) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(json_value(a_nested, '$[1]' RETURNING bigint array), ARRAY[1]) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(json_value(a_nested, '$[7][1]' RETURNING bigint array), ARRAY[1]) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(a_float, ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(json_value(a_nested, '$[2]' RETURNING decimal array), ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(json_value(a_nested, '$[7][2]' RETURNING decimal array), ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(a_str, ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(json_value(a_nested, '$[3]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(json_value(a_nested, '$[7][3]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(a_null, ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(json_value(a_nested, '$[4]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(json_value(a_nested, '$[7][4]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(a_empty, ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(json_value(a_nested, '$[5]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(json_value(a_nested, '$[7][5]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++-------+
+| col   |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(a_mixed, ARRAY[1]) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(json_value(a_nested, '$[6]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(json_value(a_nested, '$[7][6]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(a_nested, ARRAY[1]) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(json_value(a_nested, '$[7]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B7_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_overlap(json_value(a_nested, '$[7][7]' RETURNING varchar array), ARRAY[1]) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(a_bool, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(a_int, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   0 |
+|   0 |
+|   2 |
+|   2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(a_float, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(a_str, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(a_null, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(a_empty, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(a_mixed, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B8_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_offset_of(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(a_bool, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(json_value(a_nested, '$[0]' RETURNING boolean array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(json_value(a_nested, '$[7][0]' RETURNING boolean array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(a_int, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(json_value(a_nested, '$[1]' RETURNING bigint array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(json_value(a_nested, '$[7][1]' RETURNING bigint array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|   1 |
+|   1 |
+|   3 |
+|   3 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(a_float, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(json_value(a_nested, '$[2]' RETURNING decimal array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(json_value(a_nested, '$[7][2]' RETURNING decimal array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(a_str, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(json_value(a_nested, '$[3]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(json_value(a_nested, '$[7][3]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(a_null, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(json_value(a_nested, '$[4]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(json_value(a_nested, '$[7][4]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(a_empty, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(json_value(a_nested, '$[5]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(json_value(a_nested, '$[7][5]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(a_mixed, 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(json_value(a_nested, '$[6]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(json_value(a_nested, '$[7][6]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(a_nested, 1) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(json_value(a_nested, '$[7]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B9_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_ordinal_of(json_value(a_nested, '$[7][7]' RETURNING varchar array), 1) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', a_bool) AS col
+FROM test_array;
++---------------------+
+| col                 |
++---------------------+
+| [null,"1","0",null] |
+| [null,"1","0",null] |
+| [null,null,"0","1"] |
+| [null,null,"0","1"] |
++---------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
++---------------------+
+| col                 |
++---------------------+
+| [null,"1","0",null] |
+| [null,"1","0",null] |
+| [null,null,"0","1"] |
+| [null,null,"0","1"] |
++---------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
++---------------------+
+| col                 |
++---------------------+
+| [null,"1","0",null] |
+| [null,"1","0",null] |
+| [null,null,"0","1"] |
+| [null,null,"0","1"] |
++---------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', a_int) AS col
+FROM test_array;
++---------------------+
+| col                 |
++---------------------+
+| [null,"1","2",null] |
+| [null,"1","2",null] |
+| [null,null,"2","1"] |
+| [null,null,"2","1"] |
++---------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
++---------------------+
+| col                 |
++---------------------+
+| [null,"1","2",null] |
+| [null,"1","2",null] |
+| [null,null,"2","1"] |
+| [null,null,"2","1"] |
++---------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
++---------------------+
+| col                 |
++---------------------+
+| [null,"1","2",null] |
+| [null,"1","2",null] |
+| [null,null,"2","1"] |
+| [null,null,"2","1"] |
++---------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', a_float) AS col
+FROM test_array;
++-------------------------+
+| col                     |
++-------------------------+
+| [null,"0.1","0.2",null] |
+| [null,"0.1","0.2",null] |
+| [null,null,"0.2","0.1"] |
+| [null,null,"0.2","0.1"] |
++-------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
++-------------------------+
+| col                     |
++-------------------------+
+| [null,"0.1","0.2",null] |
+| [null,"0.1","0.2",null] |
+| [null,null,"0.2","0.1"] |
+| [null,null,"0.2","0.1"] |
++-------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
++-------------------------+
+| col                     |
++-------------------------+
+| [null,"0.1","0.2",null] |
+| [null,"0.1","0.2",null] |
+| [null,null,"0.2","0.1"] |
+| [null,null,"0.2","0.1"] |
++-------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', a_str) AS col
+FROM test_array;
++----------------------+
+| col                  |
++----------------------+
+| ["A","S1","S2",null] |
+| ["A","S1","S2",null] |
+| ["A",null,"S2","S1"] |
+| ["A",null,"S2","S1"] |
++----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
++----------------------+
+| col                  |
++----------------------+
+| ["A","S1","S2",null] |
+| ["A","S1","S2",null] |
+| ["A",null,"S2","S1"] |
+| ["A",null,"S2","S1"] |
++----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
++----------------------+
+| col                  |
++----------------------+
+| ["A","S1","S2",null] |
+| ["A","S1","S2",null] |
+| ["A",null,"S2","S1"] |
+| ["A",null,"S2","S1"] |
++----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', a_null) AS col
+FROM test_array;
++-----------------------+
+| col                   |
++-----------------------+
+| [null,null,null,null] |
+| [null,null,null,null] |
+| [null,null,null,null] |
+| [null,null,null,null] |
++-----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
++----------------------+
+| col                  |
++----------------------+
+| ["A",null,null,null] |
+| ["A",null,null,null] |
+| ["A",null,null,null] |
+| ["A",null,null,null] |
++----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
++----------------------+
+| col                  |
++----------------------+
+| ["A",null,null,null] |
+| ["A",null,null,null] |
+| ["A",null,null,null] |
+| ["A",null,null,null] |
++----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', a_empty) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| A   |
+| A   |
+| A   |
+| A   |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| A   |
+| A   |
+| A   |
+| A   |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', a_mixed) AS col
+FROM test_array;
++----------------------------------+
+| col                              |
++----------------------------------+
+| ["A","true","1","0.1","S1",null] |
+| ["A","true","1","0.1","S1",null] |
+| ["A",null,"S1","0.1","1","true"] |
+| ["A",null,"S1","0.1","1","true"] |
++----------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
++----------------------------------+
+| col                              |
++----------------------------------+
+| ["A","true","1","0.1","S1",null] |
+| ["A","true","1","0.1","S1",null] |
+| ["A",null,"S1","0.1","1","true"] |
+| ["A",null,"S1","0.1","1","true"] |
++----------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
++----------------------------------+
+| col                              |
++----------------------------------+
+| ["A","true","1","0.1","S1",null] |
+| ["A","true","1","0.1","S1",null] |
+| ["A",null,"S1","0.1","1","true"] |
+| ["A",null,"S1","0.1","1","true"] |
++----------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B10_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_prepend('A', json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(a_bool, 'A') AS col
+FROM test_array;
++---------------------+
+| col                 |
++---------------------+
+| ["1","0",null,null] |
+| ["1","0",null,null] |
+| [null,"0","1",null] |
+| [null,"0","1",null] |
++---------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(json_value(a_nested, '$[0]' RETURNING boolean array), 'A') AS col
+FROM test_array;
++---------------------+
+| col                 |
++---------------------+
+| ["1","0",null,null] |
+| ["1","0",null,null] |
+| [null,"0","1",null] |
+| [null,"0","1",null] |
++---------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(json_value(a_nested, '$[7][0]' RETURNING boolean array), 'A') AS col
+FROM test_array;
++---------------------+
+| col                 |
++---------------------+
+| ["1","0",null,null] |
+| ["1","0",null,null] |
+| [null,"0","1",null] |
+| [null,"0","1",null] |
++---------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(a_int, 'A') AS col
+FROM test_array;
++---------------------+
+| col                 |
++---------------------+
+| ["1","2",null,null] |
+| ["1","2",null,null] |
+| [null,"2","1",null] |
+| [null,"2","1",null] |
++---------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(json_value(a_nested, '$[1]' RETURNING bigint array), 'A') AS col
+FROM test_array;
++---------------------+
+| col                 |
++---------------------+
+| ["1","2",null,null] |
+| ["1","2",null,null] |
+| [null,"2","1",null] |
+| [null,"2","1",null] |
++---------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(json_value(a_nested, '$[7][1]' RETURNING bigint array), 'A') AS col
+FROM test_array;
++---------------------+
+| col                 |
++---------------------+
+| ["1","2",null,null] |
+| ["1","2",null,null] |
+| [null,"2","1",null] |
+| [null,"2","1",null] |
++---------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(a_float, 'A') AS col
+FROM test_array;
++-------------------------+
+| col                     |
++-------------------------+
+| ["0.1","0.2",null,null] |
+| ["0.1","0.2",null,null] |
+| [null,"0.2","0.1",null] |
+| [null,"0.2","0.1",null] |
++-------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(json_value(a_nested, '$[2]' RETURNING decimal array), 'A') AS col
+FROM test_array;
++-------------------------+
+| col                     |
++-------------------------+
+| ["0.1","0.2",null,null] |
+| ["0.1","0.2",null,null] |
+| [null,"0.2","0.1",null] |
+| [null,"0.2","0.1",null] |
++-------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(json_value(a_nested, '$[7][2]' RETURNING decimal array), 'A') AS col
+FROM test_array;
++-------------------------+
+| col                     |
++-------------------------+
+| ["0.1","0.2",null,null] |
+| ["0.1","0.2",null,null] |
+| [null,"0.2","0.1",null] |
+| [null,"0.2","0.1",null] |
++-------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(a_str, 'A') AS col
+FROM test_array;
++----------------------+
+| col                  |
++----------------------+
+| ["S1","S2",null,"A"] |
+| ["S1","S2",null,"A"] |
+| [null,"S2","S1","A"] |
+| [null,"S2","S1","A"] |
++----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(json_value(a_nested, '$[3]' RETURNING varchar array), 'A') AS col
+FROM test_array;
++----------------------+
+| col                  |
++----------------------+
+| ["S1","S2",null,"A"] |
+| ["S1","S2",null,"A"] |
+| [null,"S2","S1","A"] |
+| [null,"S2","S1","A"] |
++----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(json_value(a_nested, '$[7][3]' RETURNING varchar array), 'A') AS col
+FROM test_array;
++----------------------+
+| col                  |
++----------------------+
+| ["S1","S2",null,"A"] |
+| ["S1","S2",null,"A"] |
+| [null,"S2","S1","A"] |
+| [null,"S2","S1","A"] |
++----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(a_null, 'A') AS col
+FROM test_array;
++-----------------------+
+| col                   |
++-----------------------+
+| [null,null,null,null] |
+| [null,null,null,null] |
+| [null,null,null,null] |
+| [null,null,null,null] |
++-----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(json_value(a_nested, '$[4]' RETURNING varchar array), 'A') AS col
+FROM test_array;
++----------------------+
+| col                  |
++----------------------+
+| [null,null,null,"A"] |
+| [null,null,null,"A"] |
+| [null,null,null,"A"] |
+| [null,null,null,"A"] |
++----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(json_value(a_nested, '$[7][4]' RETURNING varchar array), 'A') AS col
+FROM test_array;
++----------------------+
+| col                  |
++----------------------+
+| [null,null,null,"A"] |
+| [null,null,null,"A"] |
+| [null,null,null,"A"] |
+| [null,null,null,"A"] |
++----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(a_empty, 'A') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(json_value(a_nested, '$[5]' RETURNING varchar array), 'A') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| A   |
+| A   |
+| A   |
+| A   |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(json_value(a_nested, '$[7][5]' RETURNING varchar array), 'A') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| A   |
+| A   |
+| A   |
+| A   |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(a_mixed, 'A') AS col
+FROM test_array;
++----------------------------------+
+| col                              |
++----------------------------------+
+| ["true","1","0.1","S1",null,"A"] |
+| ["true","1","0.1","S1",null,"A"] |
+| [null,"S1","0.1","1","true","A"] |
+| [null,"S1","0.1","1","true","A"] |
++----------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(json_value(a_nested, '$[6]' RETURNING varchar array), 'A') AS col
+FROM test_array;
++----------------------------------+
+| col                              |
++----------------------------------+
+| ["true","1","0.1","S1",null,"A"] |
+| ["true","1","0.1","S1",null,"A"] |
+| [null,"S1","0.1","1","true","A"] |
+| [null,"S1","0.1","1","true","A"] |
++----------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(json_value(a_nested, '$[7][6]' RETURNING varchar array), 'A') AS col
+FROM test_array;
++----------------------------------+
+| col                              |
++----------------------------------+
+| ["true","1","0.1","S1",null,"A"] |
+| ["true","1","0.1","S1",null,"A"] |
+| [null,"S1","0.1","1","true","A"] |
+| [null,"S1","0.1","1","true","A"] |
++----------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(a_nested, 'A') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(json_value(a_nested, '$[7]' RETURNING varchar array), 'A') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B11_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_append(json_value(a_nested, '$[7][7]' RETURNING varchar array), 'A') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(a_bool, a_bool) AS col
+FROM test_array;
++-----------------------------+
+| col                         |
++-----------------------------+
+| ["1","0",null,"1","0",null] |
+| ["1","0",null,"1","0",null] |
+| [null,"0","1",null,"0","1"] |
+| [null,"0","1",null,"0","1"] |
++-----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(json_value(a_nested, '$[0]' RETURNING boolean array), json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
++-----------------------------+
+| col                         |
++-----------------------------+
+| ["1","0",null,"1","0",null] |
+| ["1","0",null,"1","0",null] |
+| [null,"0","1",null,"0","1"] |
+| [null,"0","1",null,"0","1"] |
++-----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(json_value(a_nested, '$[7][0]' RETURNING boolean array), json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
++-----------------------------+
+| col                         |
++-----------------------------+
+| ["1","0",null,"1","0",null] |
+| ["1","0",null,"1","0",null] |
+| [null,"0","1",null,"0","1"] |
+| [null,"0","1",null,"0","1"] |
++-----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(a_int, a_int) AS col
+FROM test_array;
++-----------------------------+
+| col                         |
++-----------------------------+
+| ["1","2",null,"1","2",null] |
+| ["1","2",null,"1","2",null] |
+| [null,"2","1",null,"2","1"] |
+| [null,"2","1",null,"2","1"] |
++-----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(json_value(a_nested, '$[1]' RETURNING bigint array), json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
++-----------------------------+
+| col                         |
++-----------------------------+
+| ["1","2",null,"1","2",null] |
+| ["1","2",null,"1","2",null] |
+| [null,"2","1",null,"2","1"] |
+| [null,"2","1",null,"2","1"] |
++-----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(json_value(a_nested, '$[7][1]' RETURNING bigint array), json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
++-----------------------------+
+| col                         |
++-----------------------------+
+| ["1","2",null,"1","2",null] |
+| ["1","2",null,"1","2",null] |
+| [null,"2","1",null,"2","1"] |
+| [null,"2","1",null,"2","1"] |
++-----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(a_float, a_float) AS col
+FROM test_array;
++-------------------------------------+
+| col                                 |
++-------------------------------------+
+| ["0.1","0.2",null,"0.1","0.2",null] |
+| ["0.1","0.2",null,"0.1","0.2",null] |
+| [null,"0.2","0.1",null,"0.2","0.1"] |
+| [null,"0.2","0.1",null,"0.2","0.1"] |
++-------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(json_value(a_nested, '$[2]' RETURNING decimal array), json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
++-------------------------------------+
+| col                                 |
++-------------------------------------+
+| ["0.1","0.2",null,"0.1","0.2",null] |
+| ["0.1","0.2",null,"0.1","0.2",null] |
+| [null,"0.2","0.1",null,"0.2","0.1"] |
+| [null,"0.2","0.1",null,"0.2","0.1"] |
++-------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(json_value(a_nested, '$[7][2]' RETURNING decimal array), json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
++-------------------------------------+
+| col                                 |
++-------------------------------------+
+| ["0.1","0.2",null,"0.1","0.2",null] |
+| ["0.1","0.2",null,"0.1","0.2",null] |
+| [null,"0.2","0.1",null,"0.2","0.1"] |
+| [null,"0.2","0.1",null,"0.2","0.1"] |
++-------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(a_str, a_str) AS col
+FROM test_array;
++---------------------------------+
+| col                             |
++---------------------------------+
+| ["S1","S2",null,"S1","S2",null] |
+| ["S1","S2",null,"S1","S2",null] |
+| [null,"S2","S1",null,"S2","S1"] |
+| [null,"S2","S1",null,"S2","S1"] |
++---------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(json_value(a_nested, '$[3]' RETURNING varchar array), json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
++---------------------------------+
+| col                             |
++---------------------------------+
+| ["S1","S2",null,"S1","S2",null] |
+| ["S1","S2",null,"S1","S2",null] |
+| [null,"S2","S1",null,"S2","S1"] |
+| [null,"S2","S1",null,"S2","S1"] |
++---------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(json_value(a_nested, '$[7][3]' RETURNING varchar array), json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
++---------------------------------+
+| col                             |
++---------------------------------+
+| ["S1","S2",null,"S1","S2",null] |
+| ["S1","S2",null,"S1","S2",null] |
+| [null,"S2","S1",null,"S2","S1"] |
+| [null,"S2","S1",null,"S2","S1"] |
++---------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(a_null, a_null) AS col
+FROM test_array;
++---------------------------------+
+| col                             |
++---------------------------------+
+| [null,null,null,null,null,null] |
+| [null,null,null,null,null,null] |
+| [null,null,null,null,null,null] |
+| [null,null,null,null,null,null] |
++---------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(json_value(a_nested, '$[4]' RETURNING varchar array), json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
++---------------------------------+
+| col                             |
++---------------------------------+
+| [null,null,null,null,null,null] |
+| [null,null,null,null,null,null] |
+| [null,null,null,null,null,null] |
+| [null,null,null,null,null,null] |
++---------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(json_value(a_nested, '$[7][4]' RETURNING varchar array), json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
++---------------------------------+
+| col                             |
++---------------------------------+
+| [null,null,null,null,null,null] |
+| [null,null,null,null,null,null] |
+| [null,null,null,null,null,null] |
+| [null,null,null,null,null,null] |
++---------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(a_empty, a_empty) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(json_value(a_nested, '$[5]' RETURNING varchar array), json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(json_value(a_nested, '$[7][5]' RETURNING varchar array), json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(a_mixed, a_mixed) AS col
+FROM test_array;
++---------------------------------------------------------+
+| col                                                     |
++---------------------------------------------------------+
+| ["true","1","0.1","S1",null,"true","1","0.1","S1",null] |
+| ["true","1","0.1","S1",null,"true","1","0.1","S1",null] |
+| [null,"S1","0.1","1","true",null,"S1","0.1","1","true"] |
+| [null,"S1","0.1","1","true",null,"S1","0.1","1","true"] |
++---------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(json_value(a_nested, '$[6]' RETURNING varchar array), json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
++---------------------------------------------------------+
+| col                                                     |
++---------------------------------------------------------+
+| ["true","1","0.1","S1",null,"true","1","0.1","S1",null] |
+| ["true","1","0.1","S1",null,"true","1","0.1","S1",null] |
+| [null,"S1","0.1","1","true",null,"S1","0.1","1","true"] |
+| [null,"S1","0.1","1","true",null,"S1","0.1","1","true"] |
++---------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(json_value(a_nested, '$[7][6]' RETURNING varchar array), json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
++---------------------------------------------------------+
+| col                                                     |
++---------------------------------------------------------+
+| ["true","1","0.1","S1",null,"true","1","0.1","S1",null] |
+| ["true","1","0.1","S1",null,"true","1","0.1","S1",null] |
+| [null,"S1","0.1","1","true",null,"S1","0.1","1","true"] |
+| [null,"S1","0.1","1","true",null,"S1","0.1","1","true"] |
++---------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(a_nested, a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(json_value(a_nested, '$[7]' RETURNING varchar array), json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B12_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_concat(json_value(a_nested, '$[7][7]' RETURNING varchar array), json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(a_bool, 0, 2) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| ["1","0"]  |
+| ["1","0"]  |
+| [null,"0"] |
+| [null,"0"] |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(json_value(a_nested, '$[0]' RETURNING boolean array), 0, 2) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| ["1","0"]  |
+| ["1","0"]  |
+| [null,"0"] |
+| [null,"0"] |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(json_value(a_nested, '$[7][0]' RETURNING boolean array), 0, 2) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| ["1","0"]  |
+| ["1","0"]  |
+| [null,"0"] |
+| [null,"0"] |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(a_int, 0, 2) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| ["1","2"]  |
+| ["1","2"]  |
+| [null,"2"] |
+| [null,"2"] |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(json_value(a_nested, '$[1]' RETURNING bigint array), 0, 2) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| ["1","2"]  |
+| ["1","2"]  |
+| [null,"2"] |
+| [null,"2"] |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(json_value(a_nested, '$[7][1]' RETURNING bigint array), 0, 2) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| ["1","2"]  |
+| ["1","2"]  |
+| [null,"2"] |
+| [null,"2"] |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(a_float, 0, 2) AS col
+FROM test_array;
++---------------+
+| col           |
++---------------+
+| ["0.1","0.2"] |
+| ["0.1","0.2"] |
+| [null,"0.2"]  |
+| [null,"0.2"]  |
++---------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(json_value(a_nested, '$[2]' RETURNING decimal array), 0, 2) AS col
+FROM test_array;
++---------------+
+| col           |
++---------------+
+| ["0.1","0.2"] |
+| ["0.1","0.2"] |
+| [null,"0.2"]  |
+| [null,"0.2"]  |
++---------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(json_value(a_nested, '$[7][2]' RETURNING decimal array), 0, 2) AS col
+FROM test_array;
++---------------+
+| col           |
++---------------+
+| ["0.1","0.2"] |
+| ["0.1","0.2"] |
+| [null,"0.2"]  |
+| [null,"0.2"]  |
++---------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(a_str, 0, 2) AS col
+FROM test_array;
++-------------+
+| col         |
++-------------+
+| ["S1","S2"] |
+| ["S1","S2"] |
+| [null,"S2"] |
+| [null,"S2"] |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(json_value(a_nested, '$[3]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++-------------+
+| col         |
++-------------+
+| ["S1","S2"] |
+| ["S1","S2"] |
+| [null,"S2"] |
+| [null,"S2"] |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(json_value(a_nested, '$[7][3]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++-------------+
+| col         |
++-------------+
+| ["S1","S2"] |
+| ["S1","S2"] |
+| [null,"S2"] |
+| [null,"S2"] |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(a_null, 0, 2) AS col
+FROM test_array;
++-------------+
+| col         |
++-------------+
+| [null,null] |
+| [null,null] |
+| [null,null] |
+| [null,null] |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(json_value(a_nested, '$[4]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++-------------+
+| col         |
++-------------+
+| [null,null] |
+| [null,null] |
+| [null,null] |
+| [null,null] |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(json_value(a_nested, '$[7][4]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++-------------+
+| col         |
++-------------+
+| [null,null] |
+| [null,null] |
+| [null,null] |
+| [null,null] |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(a_empty, 0, 2) AS col
+FROM test_array;
++-------------+
+| col         |
++-------------+
+| [null,null] |
+| [null,null] |
+| [null,null] |
+| [null,null] |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(json_value(a_nested, '$[5]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++-------------+
+| col         |
++-------------+
+| [null,null] |
+| [null,null] |
+| [null,null] |
+| [null,null] |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(json_value(a_nested, '$[7][5]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++-------------+
+| col         |
++-------------+
+| [null,null] |
+| [null,null] |
+| [null,null] |
+| [null,null] |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(a_mixed, 0, 2) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| ["true","1"] |
+| ["true","1"] |
+| [null,"S1"]  |
+| [null,"S1"]  |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(json_value(a_nested, '$[6]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| ["true","1"] |
+| ["true","1"] |
+| [null,"S1"]  |
+| [null,"S1"]  |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(json_value(a_nested, '$[7][6]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| ["true","1"] |
+| ["true","1"] |
+| [null,"S1"]  |
+| [null,"S1"]  |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(a_nested, 0, 2) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(json_value(a_nested, '$[7]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B13_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_slice(json_value(a_nested, '$[7][7]' RETURNING varchar array), 0, 2) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(a_bool, '|') AS col
+FROM test_array;
++----------+
+| col      |
++----------+
+| 1|0|null |
+| 1|0|null |
+| null|0|1 |
+| null|0|1 |
++----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(json_value(a_nested, '$[0]' RETURNING boolean array), '|') AS col
+FROM test_array;
++----------+
+| col      |
++----------+
+| 1|0|null |
+| 1|0|null |
+| null|0|1 |
+| null|0|1 |
++----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(json_value(a_nested, '$[7][0]' RETURNING boolean array), '|') AS col
+FROM test_array;
++----------+
+| col      |
++----------+
+| 1|0|null |
+| 1|0|null |
+| null|0|1 |
+| null|0|1 |
++----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(a_int, '|') AS col
+FROM test_array;
++----------+
+| col      |
++----------+
+| 1|2|null |
+| 1|2|null |
+| null|2|1 |
+| null|2|1 |
++----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(json_value(a_nested, '$[1]' RETURNING bigint array), '|') AS col
+FROM test_array;
++----------+
+| col      |
++----------+
+| 1|2|null |
+| 1|2|null |
+| null|2|1 |
+| null|2|1 |
++----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(json_value(a_nested, '$[7][1]' RETURNING bigint array), '|') AS col
+FROM test_array;
++----------+
+| col      |
++----------+
+| 1|2|null |
+| 1|2|null |
+| null|2|1 |
+| null|2|1 |
++----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(a_float, '|') AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| 0.1|0.2|null |
+| 0.1|0.2|null |
+| null|0.2|0.1 |
+| null|0.2|0.1 |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(json_value(a_nested, '$[2]' RETURNING decimal array), '|') AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| 0.1|0.2|null |
+| 0.1|0.2|null |
+| null|0.2|0.1 |
+| null|0.2|0.1 |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(json_value(a_nested, '$[7][2]' RETURNING decimal array), '|') AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| 0.1|0.2|null |
+| 0.1|0.2|null |
+| null|0.2|0.1 |
+| null|0.2|0.1 |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(a_str, '|') AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| S1|S2|null |
+| S1|S2|null |
+| null|S2|S1 |
+| null|S2|S1 |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(json_value(a_nested, '$[3]' RETURNING varchar array), '|') AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| S1|S2|null |
+| S1|S2|null |
+| null|S2|S1 |
+| null|S2|S1 |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(json_value(a_nested, '$[7][3]' RETURNING varchar array), '|') AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| S1|S2|null |
+| S1|S2|null |
+| null|S2|S1 |
+| null|S2|S1 |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(a_null, '|') AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| null|null|null |
+| null|null|null |
+| null|null|null |
+| null|null|null |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(json_value(a_nested, '$[4]' RETURNING varchar array), '|') AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| null|null|null |
+| null|null|null |
+| null|null|null |
+| null|null|null |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(json_value(a_nested, '$[7][4]' RETURNING varchar array), '|') AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| null|null|null |
+| null|null|null |
+| null|null|null |
+| null|null|null |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(a_empty, '|') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(json_value(a_nested, '$[5]' RETURNING varchar array), '|') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(json_value(a_nested, '$[7][5]' RETURNING varchar array), '|') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(a_mixed, '|') AS col
+FROM test_array;
++--------------------+
+| col                |
++--------------------+
+| null|S1|0.1|1|true |
+| null|S1|0.1|1|true |
+| true|1|0.1|S1|null |
+| true|1|0.1|S1|null |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(json_value(a_nested, '$[6]' RETURNING varchar array), '|') AS col
+FROM test_array;
++--------------------+
+| col                |
++--------------------+
+| null|S1|0.1|1|true |
+| null|S1|0.1|1|true |
+| true|1|0.1|S1|null |
+| true|1|0.1|S1|null |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(json_value(a_nested, '$[7][6]' RETURNING varchar array), '|') AS col
+FROM test_array;
++--------------------+
+| col                |
++--------------------+
+| null|S1|0.1|1|true |
+| null|S1|0.1|1|true |
+| true|1|0.1|S1|null |
+| true|1|0.1|S1|null |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(a_nested, '|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(json_value(a_nested, '$[7]' RETURNING varchar array), '|') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B14_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_string(json_value(a_nested, '$[7][7]' RETURNING varchar array), '|') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C0_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv('true|1|0.1|S1|null', '\|') AS col
+FROM test_array;
++--------------------------------+
+| col                            |
++--------------------------------+
+| ["true","1","0.1","S1","null"] |
+| ["true","1","0.1","S1","null"] |
+| ["true","1","0.1","S1","null"] |
+| ["true","1","0.1","S1","null"] |
++--------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(a_bool, '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(json_value(a_nested, '$[0]' RETURNING boolean array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(json_value(a_nested, '$[7][0]' RETURNING boolean array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(a_int, '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(json_value(a_nested, '$[1]' RETURNING bigint array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(json_value(a_nested, '$[7][1]' RETURNING bigint array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(a_float, '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(json_value(a_nested, '$[2]' RETURNING decimal array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(json_value(a_nested, '$[7][2]' RETURNING decimal array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(a_str, '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(json_value(a_nested, '$[3]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(json_value(a_nested, '$[7][3]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(a_null, '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(json_value(a_nested, '$[4]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(json_value(a_nested, '$[7][4]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(a_empty, '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(json_value(a_nested, '$[5]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(json_value(a_nested, '$[7][5]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(a_mixed, '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(json_value(a_nested, '$[6]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(json_value(a_nested, '$[7][6]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(a_nested, '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(json_value(a_nested, '$[7]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B15_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT string_to_mv(json_value(a_nested, '$[7][7]' RETURNING varchar array), '\|') AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(a_bool) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
+should be an identifier expression. Use array() instead
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
+should be an identifier expression. Use array() instead
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(a_int) AS col
+FROM test_array;
++--------------+
+| col          |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
+should be an identifier expression. Use array() instead
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
+should be an identifier expression. Use array() instead
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(a_float) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
+should be an identifier expression. Use array() instead
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
+should be an identifier expression. Use array() instead
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(a_str) AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
+should be an identifier expression. Use array() instead
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
+should be an identifier expression. Use array() instead
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(a_null) AS col
+FROM test_array;
++--------------------+
+| col                |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
+should be an identifier expression. Use array() instead
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
+should be an identifier expression. Use array() instead
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(a_empty) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
+should be an identifier expression. Use array() instead
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
+should be an identifier expression. Use array() instead
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(a_mixed) AS col
+FROM test_array;
++--------------------------+
+| col                      |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
+should be an identifier expression. Use array() instead
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
+should be an identifier expression. Use array() instead
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(a_nested) AS col
+FROM test_array;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
+should be an identifier expression. Use array() instead
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_mv_funcs TEST_ID: A1_B16_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT mv_to_array(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
+should be an identifier expression. Use array() instead
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(a_bool, '$.') AS col
+FROM test_array;
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(json_value(a_nested, '$[0]' RETURNING boolean array), '$.') AS col
+FROM test_array;
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(json_value(a_nested, '$[7][0]' RETURNING boolean array), '$.') AS col
+FROM test_array;
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(a_int, '$.') AS col
+FROM test_array;
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(json_value(a_nested, '$[1]' RETURNING bigint array), '$.') AS col
+FROM test_array;
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(json_value(a_nested, '$[7][1]' RETURNING bigint array), '$.') AS col
+FROM test_array;
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(a_float, '$.') AS col
+FROM test_array;
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(json_value(a_nested, '$[2]' RETURNING decimal array), '$.') AS col
+FROM test_array;
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(json_value(a_nested, '$[7][2]' RETURNING decimal array), '$.') AS col
+FROM test_array;
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(a_str, '$.') AS col
+FROM test_array;
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(json_value(a_nested, '$[3]' RETURNING varchar array), '$.') AS col
+FROM test_array;
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(json_value(a_nested, '$[7][3]' RETURNING varchar array), '$.') AS col
+FROM test_array;
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(a_null, '$.') AS col
+FROM test_array;
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(json_value(a_nested, '$[4]' RETURNING varchar array), '$.') AS col
+FROM test_array;
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(json_value(a_nested, '$[7][4]' RETURNING varchar array), '$.') AS col
+FROM test_array;
++-----------+
+| col       |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
+| [0, 1, 2] |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(a_empty, '$.') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(json_value(a_nested, '$[5]' RETURNING varchar array), '$.') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(json_value(a_nested, '$[7][5]' RETURNING varchar array), '$.') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(a_mixed, '$.') AS col
+FROM test_array;
++-----------------+
+| col             |
++-----------------+
+| [0, 1, 2, 3, 4] |
+| [0, 1, 2, 3, 4] |
+| [0, 1, 2, 3, 4] |
+| [0, 1, 2, 3, 4] |
++-----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(json_value(a_nested, '$[6]' RETURNING varchar array), '$.') AS col
+FROM test_array;
++-----------------+
+| col             |
++-----------------+
+| [0, 1, 2, 3, 4] |
+| [0, 1, 2, 3, 4] |
+| [0, 1, 2, 3, 4] |
+| [0, 1, 2, 3, 4] |
++-----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(json_value(a_nested, '$[7][6]' RETURNING varchar array), '$.') AS col
+FROM test_array;
++-----------------+
+| col             |
++-----------------+
+| [0, 1, 2, 3, 4] |
+| [0, 1, 2, 3, 4] |
+| [0, 1, 2, 3, 4] |
+| [0, 1, 2, 3, 4] |
++-----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C22_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(a_nested, '$.') AS col
+FROM test_array;
++--------------------------+
+| col                      |
++--------------------------+
+| [0, 1, 2, 3, 4, 5, 6, 7] |
+| [0, 1, 2, 3, 4, 5, 6, 7] |
+| [0, 1, 2, 3, 4, 5, 6, 7] |
+| [0, 1, 2, 3, 4, 5, 6, 7] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(json_value(a_nested, '$[7]' RETURNING varchar array), '$.') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B1_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(json_value(a_nested, '$[7][7]' RETURNING varchar array), '$.') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value a_bool) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| {"k":[1,0,null]} |
+| {"k":[1,0,null]} |
+| {"k":[null,0,1]} |
+| {"k":[null,0,1]} |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| {"k":[1,0,null]} |
+| {"k":[1,0,null]} |
+| {"k":[null,0,1]} |
+| {"k":[null,0,1]} |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| {"k":[1,0,null]} |
+| {"k":[1,0,null]} |
+| {"k":[null,0,1]} |
+| {"k":[null,0,1]} |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value a_int) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| {"k":[1,2,null]} |
+| {"k":[1,2,null]} |
+| {"k":[null,2,1]} |
+| {"k":[null,2,1]} |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| {"k":[1,2,null]} |
+| {"k":[1,2,null]} |
+| {"k":[null,2,1]} |
+| {"k":[null,2,1]} |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| {"k":[1,2,null]} |
+| {"k":[1,2,null]} |
+| {"k":[null,2,1]} |
+| {"k":[null,2,1]} |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value a_float) AS col
+FROM test_array;
++----------------------+
+| col                  |
++----------------------+
+| {"k":[0.1,0.2,null]} |
+| {"k":[0.1,0.2,null]} |
+| {"k":[null,0.2,0.1]} |
+| {"k":[null,0.2,0.1]} |
++----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
++----------------------+
+| col                  |
++----------------------+
+| {"k":[0.1,0.2,null]} |
+| {"k":[0.1,0.2,null]} |
+| {"k":[null,0.2,0.1]} |
+| {"k":[null,0.2,0.1]} |
++----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
++----------------------+
+| col                  |
++----------------------+
+| {"k":[0.1,0.2,null]} |
+| {"k":[0.1,0.2,null]} |
+| {"k":[null,0.2,0.1]} |
+| {"k":[null,0.2,0.1]} |
++----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value a_str) AS col
+FROM test_array;
++------------------------+
+| col                    |
++------------------------+
+| {"k":["S1","S2",null]} |
+| {"k":["S1","S2",null]} |
+| {"k":[null,"S2","S1"]} |
+| {"k":[null,"S2","S1"]} |
++------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------------+
+| col                    |
++------------------------+
+| {"k":["S1","S2",null]} |
+| {"k":["S1","S2",null]} |
+| {"k":[null,"S2","S1"]} |
+| {"k":[null,"S2","S1"]} |
++------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------------+
+| col                    |
++------------------------+
+| {"k":["S1","S2",null]} |
+| {"k":["S1","S2",null]} |
+| {"k":[null,"S2","S1"]} |
+| {"k":[null,"S2","S1"]} |
++------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value a_null) AS col
+FROM test_array;
++------------------------+
+| col                    |
++------------------------+
+| {"k":[null,null,null]} |
+| {"k":[null,null,null]} |
+| {"k":[null,null,null]} |
+| {"k":[null,null,null]} |
++------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------------+
+| col                    |
++------------------------+
+| {"k":[null,null,null]} |
+| {"k":[null,null,null]} |
+| {"k":[null,null,null]} |
+| {"k":[null,null,null]} |
++------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------------+
+| col                    |
++------------------------+
+| {"k":[null,null,null]} |
+| {"k":[null,null,null]} |
+| {"k":[null,null,null]} |
+| {"k":[null,null,null]} |
++------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value a_empty) AS col
+FROM test_array;
++----------+
+| col      |
++----------+
+| {"k":[]} |
+| {"k":[]} |
+| {"k":[]} |
+| {"k":[]} |
++----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
++----------+
+| col      |
++----------+
+| {"k":[]} |
+| {"k":[]} |
+| {"k":[]} |
+| {"k":[]} |
++----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
++----------+
+| col      |
++----------+
+| {"k":[]} |
+| {"k":[]} |
+| {"k":[]} |
+| {"k":[]} |
++----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value a_mixed) AS col
+FROM test_array;
++------------------------------------+
+| col                                |
++------------------------------------+
+| {"k":["true","1","0.1","S1",null]} |
+| {"k":["true","1","0.1","S1",null]} |
+| {"k":[null,"S1","0.1","1","true"]} |
+| {"k":[null,"S1","0.1","1","true"]} |
++------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------------------------+
+| col                                |
++------------------------------------+
+| {"k":["true","1","0.1","S1",null]} |
+| {"k":["true","1","0.1","S1",null]} |
+| {"k":[null,"S1","0.1","1","true"]} |
+| {"k":[null,"S1","0.1","1","true"]} |
++------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------------------------+
+| col                                |
++------------------------------------+
+| {"k":["true","1","0.1","S1",null]} |
+| {"k":["true","1","0.1","S1",null]} |
+| {"k":[null,"S1","0.1","1","true"]} |
+| {"k":[null,"S1","0.1","1","true"]} |
++------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C22_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value a_nested) AS col
+FROM test_array;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                                                                                                                                                                                                                 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"k":[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]]} |
+| {"k":[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]]} |
+| {"k":[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]]} |
+| {"k":[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]]} |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| {"k":null} |
+| {"k":null} |
+| {"k":null} |
+| {"k":null} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B2_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'k' value json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| {"k":null} |
+| {"k":null} |
+| {"k":null} |
+| {"k":null} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(a_bool) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(a_int) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(a_float) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(a_str) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(a_null) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(a_empty) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(a_mixed) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C22_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(a_nested) AS col
+FROM test_array;
++-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                                                                           |
++-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [$[2], $[7][6], $[7][7][3], $[3], $[7][7][2], $[4], $[7][7][5], $[5], $[7][7][4], $[6], $[7][7][6], $[7][0], $[7][1], $[7][2], $[7][3], $[0], $[7][4], $[7][7][1], $[1], $[7][5], $[7][7][0]] |
+| [$[2], $[7][6], $[7][7][3], $[3], $[7][7][2], $[4], $[7][7][5], $[5], $[7][7][4], $[6], $[7][7][6], $[7][0], $[7][1], $[7][2], $[7][3], $[0], $[7][4], $[7][7][1], $[1], $[7][5], $[7][7][0]] |
+| [$[2], $[7][6], $[7][7][3], $[3], $[7][7][2], $[4], $[7][7][5], $[5], $[7][7][4], $[6], $[7][7][6], $[7][0], $[7][1], $[7][2], $[7][3], $[0], $[7][4], $[7][7][1], $[1], $[7][5], $[7][7][0]] |
+| [$[2], $[7][6], $[7][7][3], $[3], $[7][7][2], $[4], $[7][7][5], $[5], $[7][7][4], $[6], $[7][7][6], $[7][0], $[7][1], $[7][2], $[7][3], $[0], $[7][4], $[7][7][1], $[1], $[7][5], $[7][7][0]] |
++-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B3_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_bool, '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(json_value(a_nested, '$[0]' RETURNING boolean array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(json_value(a_nested, '$[7][0]' RETURNING boolean array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_int, '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(json_value(a_nested, '$[1]' RETURNING bigint array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(json_value(a_nested, '$[7][1]' RETURNING bigint array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_float, '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(json_value(a_nested, '$[2]' RETURNING decimal array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(json_value(a_nested, '$[7][2]' RETURNING decimal array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_str, '$[0]') AS col
+FROM test_array;
++------+
+| col  |
++------+
+| "S1" |
+| "S1" |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(json_value(a_nested, '$[3]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++------+
+| col  |
++------+
+| "S1" |
+| "S1" |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(json_value(a_nested, '$[7][3]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++------+
+| col  |
++------+
+| "S1" |
+| "S1" |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_null, '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(json_value(a_nested, '$[4]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(json_value(a_nested, '$[7][4]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_empty, '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(json_value(a_nested, '$[5]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(json_value(a_nested, '$[7][5]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_mixed, '$[0]') AS col
+FROM test_array;
++--------+
+| col    |
++--------+
+| "true" |
+| "true" |
+|        |
+|        |
++--------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(json_value(a_nested, '$[6]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++--------+
+| col    |
++--------+
+| "true" |
+| "true" |
+|        |
+|        |
++--------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(json_value(a_nested, '$[7][6]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++--------+
+| col    |
++--------+
+| "true" |
+| "true" |
+|        |
+|        |
++--------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C22_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_nested, '$[0]') AS col
+FROM test_array;
++-------------------+
+| col               |
++-------------------+
+| [null,false,true] |
+| [null,false,true] |
+| [true,false,null] |
+| [true,false,null] |
++-------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(json_value(a_nested, '$[7]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B4_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(json_value(a_nested, '$[7][7]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_bool, '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_value(a_nested, '$[0]' RETURNING boolean array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_value(a_nested, '$[7][0]' RETURNING boolean array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_int, '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_value(a_nested, '$[1]' RETURNING bigint array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_value(a_nested, '$[7][1]' RETURNING bigint array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 1   |
+| 1   |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_float, '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_value(a_nested, '$[2]' RETURNING decimal array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_value(a_nested, '$[7][2]' RETURNING decimal array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_str, '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| S1  |
+| S1  |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_value(a_nested, '$[3]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| S1  |
+| S1  |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_value(a_nested, '$[7][3]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| S1  |
+| S1  |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_null, '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_value(a_nested, '$[4]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_value(a_nested, '$[7][4]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_empty, '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_value(a_nested, '$[5]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_value(a_nested, '$[7][5]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_mixed, '$[0]') AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_value(a_nested, '$[6]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_value(a_nested, '$[7][6]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++------+
+| col  |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_value(a_nested, '$[7]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B5_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_value(a_nested, '$[7][7]' RETURNING varchar array), '$[0]') AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(a_bool) AS col
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING parse_json(json_value(a_nested, '$[7][0]' RETURNING boolean array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(a_int) AS col
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING parse_json(json_value(a_nested, '$[7][1]' RETURNING bigint array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(a_float) AS col
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING parse_json(json_value(a_nested, '$[7][2]' RETURNING decimal array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(a_str) AS col
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING parse_json(json_value(a_nested, '$[7][3]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(a_null) AS col
+FROM test_array
+WHERE a_null<>ARRAY[NULL,
+                    NULL,
+                    NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING parse_json(json_value(a_nested, '$[7][4]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(a_empty) AS col
+FROM test_array
+WHERE a_empty<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING parse_json(json_value(a_nested, '$[7][5]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(a_mixed) AS col
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING parse_json(json_value(a_nested, '$[7][6]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(a_nested) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B6_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING parse_json(json_value(a_nested, '$[7][7]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C1_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(a_bool) AS col
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C2_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[0]' RETURNING boolean array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C3_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][0]' RETURNING boolean array)
+HAVING try_parse_json(json_value(a_nested, '$[7][0]' RETURNING boolean array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C4_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(a_int) AS col
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C5_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C6_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING try_parse_json(json_value(a_nested, '$[7][1]' RETURNING bigint array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C7_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(a_float) AS col
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C8_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C9_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING try_parse_json(json_value(a_nested, '$[7][2]' RETURNING decimal array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C10_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(a_str) AS col
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C11_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C12_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING try_parse_json(json_value(a_nested, '$[7][3]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C13_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(a_null) AS col
+FROM test_array
+WHERE a_null<>ARRAY[NULL,
+                    NULL,
+                    NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C14_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C15_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING try_parse_json(json_value(a_nested, '$[7][4]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C16_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(a_empty) AS col
+FROM test_array
+WHERE a_empty<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C17_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C18_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING try_parse_json(json_value(a_nested, '$[7][5]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C19_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(a_mixed) AS col
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C20_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C21_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING try_parse_json(json_value(a_nested, '$[7][6]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C22_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(a_nested) AS col
+FROM test_array
+WHERE a_nested<>ARRAY['FILLER'];
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C23_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7]' RETURNING varchar array);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B7_C24_D1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][7]' RETURNING varchar array)
+HAVING try_parse_json(json_value(a_nested, '$[7][7]' RETURNING varchar array)) IS NOT NULL;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C1_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(a_bool) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| [1,0,null] |
+| [1,0,null] |
+| [null,0,1] |
+| [null,0,1] |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C2_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(a_nested, '$[0]' RETURNING boolean array)) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| [1,0,null] |
+| [1,0,null] |
+| [null,0,1] |
+| [null,0,1] |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C3_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(a_nested, '$[7][0]' RETURNING boolean array)) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| [1,0,null] |
+| [1,0,null] |
+| [null,0,1] |
+| [null,0,1] |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C4_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(a_int) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| [1,2,null] |
+| [1,2,null] |
+| [null,2,1] |
+| [null,2,1] |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C5_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(a_nested, '$[1]' RETURNING bigint array)) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| [1,2,null] |
+| [1,2,null] |
+| [null,2,1] |
+| [null,2,1] |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C6_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(a_nested, '$[7][1]' RETURNING bigint array)) AS col
+FROM test_array;
++------------+
+| col        |
++------------+
+| [1,2,null] |
+| [1,2,null] |
+| [null,2,1] |
+| [null,2,1] |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C7_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(a_float) AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| [0.1,0.2,null] |
+| [0.1,0.2,null] |
+| [null,0.2,0.1] |
+| [null,0.2,0.1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C8_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(a_nested, '$[2]' RETURNING decimal array)) AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| [0.1,0.2,null] |
+| [0.1,0.2,null] |
+| [null,0.2,0.1] |
+| [null,0.2,0.1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C9_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(a_nested, '$[7][2]' RETURNING decimal array)) AS col
+FROM test_array;
++----------------+
+| col            |
++----------------+
+| [0.1,0.2,null] |
+| [0.1,0.2,null] |
+| [null,0.2,0.1] |
+| [null,0.2,0.1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C10_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(a_str) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| ["S1","S2",null] |
+| ["S1","S2",null] |
+| [null,"S2","S1"] |
+| [null,"S2","S1"] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C11_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(a_nested, '$[3]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| ["S1","S2",null] |
+| ["S1","S2",null] |
+| [null,"S2","S1"] |
+| [null,"S2","S1"] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C12_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(a_nested, '$[7][3]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| ["S1","S2",null] |
+| ["S1","S2",null] |
+| [null,"S2","S1"] |
+| [null,"S2","S1"] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C13_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(a_null) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| [null,null,null] |
+| [null,null,null] |
+| [null,null,null] |
+| [null,null,null] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C14_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(a_nested, '$[4]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| [null,null,null] |
+| [null,null,null] |
+| [null,null,null] |
+| [null,null,null] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C15_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(a_nested, '$[7][4]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------+
+| col              |
++------------------+
+| [null,null,null] |
+| [null,null,null] |
+| [null,null,null] |
+| [null,null,null] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C16_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(a_empty) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C17_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(a_nested, '$[5]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C18_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(a_nested, '$[7][5]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+| []  |
+| []  |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C19_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(a_mixed) AS col
+FROM test_array;
++------------------------------+
+| col                          |
++------------------------------+
+| ["true","1","0.1","S1",null] |
+| ["true","1","0.1","S1",null] |
+| [null,"S1","0.1","1","true"] |
+| [null,"S1","0.1","1","true"] |
++------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C20_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(a_nested, '$[6]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------------------+
+| col                          |
++------------------------------+
+| ["true","1","0.1","S1",null] |
+| ["true","1","0.1","S1",null] |
+| [null,"S1","0.1","1","true"] |
+| [null,"S1","0.1","1","true"] |
++------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C21_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(a_nested, '$[7][6]' RETURNING varchar array)) AS col
+FROM test_array;
++------------------------------+
+| col                          |
++------------------------------+
+| ["true","1","0.1","S1",null] |
+| ["true","1","0.1","S1",null] |
+| [null,"S1","0.1","1","true"] |
+| [null,"S1","0.1","1","true"] |
++------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C22_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(a_nested) AS col
+FROM test_array;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| col                                                                                                                                                                                                                                                                                                                           |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C23_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(a_nested, '$[7]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_json_funcs TEST_ID: A1_B8_C24_D1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(a_nested, '$[7][7]' RETURNING varchar array)) AS col
+FROM test_array;
++-----+
+| col |
++-----+
+|     |
+|     |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 3599 Positive tests: 1104 Negative tests: 2495
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaArray_sql.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaArray_sql.iq
new file mode 100644
index 000000000000..c7b0f1ecae85
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaArray_sql.iq
@@ -0,0 +1,62751 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaArray/sql&numMergeBuffers=3
+!set outputformat mysql
+SELECT count(*) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT a_bool
+FROM test_array;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "resultFormat" : "compactedList",
+  "columns" : [ "a_bool" ],
+  "columnTypes" : [ "ARRAY<LONG>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT a_int
+FROM test_array;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "resultFormat" : "compactedList",
+  "columns" : [ "a_int" ],
+  "columnTypes" : [ "ARRAY<LONG>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_value(a_nested, '$[1]' RETURNING bigint array)
+FROM test_array;
++--------------+
+| EXPR$0       |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "nested-field",
+    "columnName" : "a_nested",
+    "outputName" : "v0",
+    "expectedType" : "ARRAY<LONG>",
+    "pathParts" : [ {
+      "type" : "arrayElement",
+      "index" : 1
+    } ],
+    "processFromRaw" : false
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "ARRAY<LONG>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_value(a_nested, '$[7][1]' RETURNING bigint array)
+FROM test_array;
++--------------+
+| EXPR$0       |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "nested-field",
+    "columnName" : "a_nested",
+    "outputName" : "v0",
+    "expectedType" : "ARRAY<LONG>",
+    "pathParts" : [ {
+      "type" : "arrayElement",
+      "index" : 7
+    }, {
+      "type" : "arrayElement",
+      "index" : 1
+    } ],
+    "processFromRaw" : false
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "ARRAY<LONG>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT a_float
+FROM test_array;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "resultFormat" : "compactedList",
+  "columns" : [ "a_float" ],
+  "columnTypes" : [ "ARRAY<DOUBLE>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A8_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_value(a_nested, '$[2]' RETURNING decimal array)
+FROM test_array;
++------------------+
+| EXPR$0           |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "nested-field",
+    "columnName" : "a_nested",
+    "outputName" : "v0",
+    "expectedType" : "ARRAY<DOUBLE>",
+    "pathParts" : [ {
+      "type" : "arrayElement",
+      "index" : 2
+    } ],
+    "processFromRaw" : false
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "ARRAY<DOUBLE>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A9_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_value(a_nested, '$[7][2]' RETURNING decimal array)
+FROM test_array;
++------------------+
+| EXPR$0           |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "nested-field",
+    "columnName" : "a_nested",
+    "outputName" : "v0",
+    "expectedType" : "ARRAY<DOUBLE>",
+    "pathParts" : [ {
+      "type" : "arrayElement",
+      "index" : 7
+    }, {
+      "type" : "arrayElement",
+      "index" : 2
+    } ],
+    "processFromRaw" : false
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "ARRAY<DOUBLE>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A10_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT a_str
+FROM test_array;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "resultFormat" : "compactedList",
+  "columns" : [ "a_str" ],
+  "columnTypes" : [ "ARRAY<STRING>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A11_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_value(a_nested, '$[3]' RETURNING varchar array)
+FROM test_array;
++----------------+
+| EXPR$0         |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "nested-field",
+    "columnName" : "a_nested",
+    "outputName" : "v0",
+    "expectedType" : "ARRAY<STRING>",
+    "pathParts" : [ {
+      "type" : "arrayElement",
+      "index" : 3
+    } ],
+    "processFromRaw" : false
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "ARRAY<STRING>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A12_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_value(a_nested, '$[7][3]' RETURNING varchar array)
+FROM test_array;
++----------------+
+| EXPR$0         |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "nested-field",
+    "columnName" : "a_nested",
+    "outputName" : "v0",
+    "expectedType" : "ARRAY<STRING>",
+    "pathParts" : [ {
+      "type" : "arrayElement",
+      "index" : 7
+    }, {
+      "type" : "arrayElement",
+      "index" : 3
+    } ],
+    "processFromRaw" : false
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "ARRAY<STRING>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A13_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT a_null
+FROM test_array;
++--------------------+
+| a_null             |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "resultFormat" : "compactedList",
+  "columns" : [ "a_null" ],
+  "columnTypes" : [ "ARRAY<LONG>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A14_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_value(a_nested, '$[4]' RETURNING varchar array)
+FROM test_array;
++--------------------+
+| EXPR$0             |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "nested-field",
+    "columnName" : "a_nested",
+    "outputName" : "v0",
+    "expectedType" : "ARRAY<STRING>",
+    "pathParts" : [ {
+      "type" : "arrayElement",
+      "index" : 4
+    } ],
+    "processFromRaw" : false
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "ARRAY<STRING>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A15_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_value(a_nested, '$[7][4]' RETURNING varchar array)
+FROM test_array;
++--------------------+
+| EXPR$0             |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "nested-field",
+    "columnName" : "a_nested",
+    "outputName" : "v0",
+    "expectedType" : "ARRAY<STRING>",
+    "pathParts" : [ {
+      "type" : "arrayElement",
+      "index" : 7
+    }, {
+      "type" : "arrayElement",
+      "index" : 4
+    } ],
+    "processFromRaw" : false
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "ARRAY<STRING>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A16_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT a_empty
+FROM test_array;
++---------+
+| a_empty |
++---------+
+| []      |
+| []      |
+| []      |
+| []      |
++---------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "resultFormat" : "compactedList",
+  "columns" : [ "a_empty" ],
+  "columnTypes" : [ "ARRAY<LONG>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A17_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_value(a_nested, '$[5]' RETURNING varchar array)
+FROM test_array;
++--------+
+| EXPR$0 |
++--------+
+| []     |
+| []     |
+| []     |
+| []     |
++--------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "nested-field",
+    "columnName" : "a_nested",
+    "outputName" : "v0",
+    "expectedType" : "ARRAY<STRING>",
+    "pathParts" : [ {
+      "type" : "arrayElement",
+      "index" : 5
+    } ],
+    "processFromRaw" : false
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "ARRAY<STRING>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A18_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_value(a_nested, '$[7][5]' RETURNING varchar array)
+FROM test_array;
++--------+
+| EXPR$0 |
++--------+
+| []     |
+| []     |
+| []     |
+| []     |
++--------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "nested-field",
+    "columnName" : "a_nested",
+    "outputName" : "v0",
+    "expectedType" : "ARRAY<STRING>",
+    "pathParts" : [ {
+      "type" : "arrayElement",
+      "index" : 7
+    }, {
+      "type" : "arrayElement",
+      "index" : 5
+    } ],
+    "processFromRaw" : false
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "ARRAY<STRING>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A19_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT a_mixed
+FROM test_array;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "resultFormat" : "compactedList",
+  "columns" : [ "a_mixed" ],
+  "columnTypes" : [ "ARRAY<STRING>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A20_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_value(a_nested, '$[6]' RETURNING varchar array)
+FROM test_array;
++--------------------------+
+| EXPR$0                   |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "nested-field",
+    "columnName" : "a_nested",
+    "outputName" : "v0",
+    "expectedType" : "ARRAY<STRING>",
+    "pathParts" : [ {
+      "type" : "arrayElement",
+      "index" : 6
+    } ],
+    "processFromRaw" : false
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "ARRAY<STRING>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A21_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_value(a_nested, '$[7][6]' RETURNING varchar array)
+FROM test_array;
++--------------------------+
+| EXPR$0                   |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "nested-field",
+    "columnName" : "a_nested",
+    "outputName" : "v0",
+    "expectedType" : "ARRAY<STRING>",
+    "pathParts" : [ {
+      "type" : "arrayElement",
+      "index" : 7
+    }, {
+      "type" : "arrayElement",
+      "index" : 6
+    } ],
+    "processFromRaw" : false
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "ARRAY<STRING>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A22_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT a_nested
+FROM test_array;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "resultFormat" : "compactedList",
+  "columns" : [ "a_nested" ],
+  "columnTypes" : [ "COMPLEX<json>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A23_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_value(a_nested, '$[7]' RETURNING varchar array)
+FROM test_array;
++--------+
+| EXPR$0 |
++--------+
+|        |
+|        |
+|        |
+|        |
++--------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "nested-field",
+    "columnName" : "a_nested",
+    "outputName" : "v0",
+    "expectedType" : "ARRAY<STRING>",
+    "pathParts" : [ {
+      "type" : "arrayElement",
+      "index" : 7
+    } ],
+    "processFromRaw" : false
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "ARRAY<STRING>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_explain TEST_ID: A24_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_value(a_nested, '$[7][7]' RETURNING varchar array)
+FROM test_array;
++--------+
+| EXPR$0 |
++--------+
+|        |
+|        |
+|        |
+|        |
++--------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_array"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "nested-field",
+    "columnName" : "a_nested",
+    "outputName" : "v0",
+    "expectedType" : "ARRAY<STRING>",
+    "pathParts" : [ {
+      "type" : "arrayElement",
+      "index" : 7
+    }, {
+      "type" : "arrayElement",
+      "index" : 7
+    } ],
+    "processFromRaw" : false
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "ARRAY<STRING>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A1_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(a_bool) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A1_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT a_bool) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A2_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A2_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(a_int) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A2_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT a_int) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A3_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A3_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(a_float) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A3_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT a_float) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A4_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(a_str) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A4_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT a_str) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A5_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(a_null) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A5_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT a_null) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A6_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(a_empty) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A6_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT a_empty) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A7_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(a_mixed) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A7_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT a_mixed) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A8_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A8_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(a_nested) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_count TEST_ID: A8_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(DISTINCT a_nested) cnt
+FROM test_array;
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT a_bool
+FROM test_array;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A1_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT a_bool
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT a_int
+FROM test_array;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A4_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT a_int
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(a_nested, '$[1]' RETURNING bigint array)
+FROM test_array;
++--------------+
+| EXPR$0       |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A5_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT json_value(a_nested, '$[1]' RETURNING bigint array)
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(a_nested, '$[7][1]' RETURNING bigint array)
+FROM test_array;
++--------------+
+| EXPR$0       |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A6_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT json_value(a_nested, '$[7][1]' RETURNING bigint array)
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT a_float
+FROM test_array;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A7_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT a_float
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A8_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(a_nested, '$[2]' RETURNING decimal array)
+FROM test_array;
++------------------+
+| EXPR$0           |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A8_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT json_value(a_nested, '$[2]' RETURNING decimal array)
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A9_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(a_nested, '$[7][2]' RETURNING decimal array)
+FROM test_array;
++------------------+
+| EXPR$0           |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A9_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT json_value(a_nested, '$[7][2]' RETURNING decimal array)
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A10_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT a_str
+FROM test_array;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A10_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT a_str
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A11_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(a_nested, '$[3]' RETURNING varchar array)
+FROM test_array;
++----------------+
+| EXPR$0         |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A11_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT json_value(a_nested, '$[3]' RETURNING varchar array)
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A12_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(a_nested, '$[7][3]' RETURNING varchar array)
+FROM test_array;
++----------------+
+| EXPR$0         |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A12_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT json_value(a_nested, '$[7][3]' RETURNING varchar array)
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A13_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT a_null
+FROM test_array;
++--------------------+
+| a_null             |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A13_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT a_null
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A14_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(a_nested, '$[4]' RETURNING varchar array)
+FROM test_array;
++--------------------+
+| EXPR$0             |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A14_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT json_value(a_nested, '$[4]' RETURNING varchar array)
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A15_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(a_nested, '$[7][4]' RETURNING varchar array)
+FROM test_array;
++--------------------+
+| EXPR$0             |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A15_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT json_value(a_nested, '$[7][4]' RETURNING varchar array)
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A16_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT a_empty
+FROM test_array;
++---------+
+| a_empty |
++---------+
+| []      |
++---------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A16_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT a_empty
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A17_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(a_nested, '$[5]' RETURNING varchar array)
+FROM test_array;
++--------+
+| EXPR$0 |
++--------+
+| []     |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A17_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT json_value(a_nested, '$[5]' RETURNING varchar array)
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A18_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(a_nested, '$[7][5]' RETURNING varchar array)
+FROM test_array;
++--------+
+| EXPR$0 |
++--------+
+| []     |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A18_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT json_value(a_nested, '$[7][5]' RETURNING varchar array)
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   1 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A19_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT a_mixed
+FROM test_array;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A19_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT a_mixed
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A20_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(a_nested, '$[6]' RETURNING varchar array)
+FROM test_array;
++--------------------------+
+| EXPR$0                   |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A20_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT json_value(a_nested, '$[6]' RETURNING varchar array)
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A21_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(a_nested, '$[7][6]' RETURNING varchar array)
+FROM test_array;
++--------------------------+
+| EXPR$0                   |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A21_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT json_value(a_nested, '$[7][6]' RETURNING varchar array)
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A22_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT a_nested
+FROM test_array;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A22_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT a_nested
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A23_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_query(a_nested, '$[7]')
+FROM test_array;
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| EXPR$0                                                                                                                                                                                                              |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]] |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A23_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT json_query(a_nested, '$[7]')
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A24_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_query(a_nested, '$[7][7]')
+FROM test_array;
++-----------------------------------------------------------------------------------------------------------+
+| EXPR$0                                                                                                    |
++-----------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]] |
++-----------------------------------------------------------------------------------------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_select_distinct TEST_ID: A24_B2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) cnt
+FROM
+  (SELECT DISTINCT json_query(a_nested, '$[7][7]')
+   FROM test_array);
++-----+
+| cnt |
++-----+
+|   2 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_bool=a_int;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_bool=a_int
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_int);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_int)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=a_int;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B1_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=a_int
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_int)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B1_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_int)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_bool=a_int;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B1_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_bool=a_int
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_bool=a_float;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_bool=a_float
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_float);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_float)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=a_float;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B2_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=a_float
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_float)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B2_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_float)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_bool=a_float;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B2_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_bool=a_float
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_bool=a_str;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B3_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_bool=a_str
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_str);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B3_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_str)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B3_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=a_str;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B3_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=a_str
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B3_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_str)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B3_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_str)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B3_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_bool=a_str;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B3_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_bool=a_str
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_bool=a_null;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B4_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_bool=a_null
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_null);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B4_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_null)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B4_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=a_null;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B4_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=a_null
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B4_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_null)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B4_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_null)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B4_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_bool=a_null;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B4_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_bool=a_null
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_bool=a_empty;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B5_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_bool=a_empty
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_empty);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B5_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_empty)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B5_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=a_empty;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B5_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=a_empty
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B5_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_empty)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B5_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_empty)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B5_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_bool=a_empty;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B5_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_bool=a_empty
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_bool=a_mixed;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B6_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_bool=a_mixed
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_mixed);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B6_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_mixed)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B6_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=a_mixed;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B6_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=a_mixed
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B6_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_mixed)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B6_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_mixed)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B6_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_bool=a_mixed;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B6_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_bool=a_mixed
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B7_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_bool=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B7_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_bool=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B7_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_nested);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B7_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_nested)
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B7_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B7_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B7_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_nested)
+SELECT a_int
+FROM t1;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B7_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=a_nested)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B7_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_bool=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B7_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_bool=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int=a_float;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B8_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int=a_float
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_float);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B8_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_float)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B8_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=a_float;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B8_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=a_float
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_float)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B8_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_float)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int=a_float;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B8_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int=a_float
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int=a_str;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B9_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int=a_str
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_str);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B9_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_str)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B9_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=a_str;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B9_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=a_str
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B9_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_str)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B9_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_str)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B9_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int=a_str;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B9_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int=a_str
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int=a_null;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B10_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int=a_null
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_null);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B10_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_null)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B10_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=a_null;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B10_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=a_null
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B10_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_null)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B10_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_null)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B10_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int=a_null;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B10_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int=a_null
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int=a_empty;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B11_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int=a_empty
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_empty);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B11_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_empty)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B11_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=a_empty;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B11_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=a_empty
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B11_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_empty)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B11_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_empty)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B11_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int=a_empty;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B11_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int=a_empty
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int=a_mixed;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B12_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int=a_mixed
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_mixed);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B12_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_mixed)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B12_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=a_mixed;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B12_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=a_mixed
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B12_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_mixed)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B12_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_mixed)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B12_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int=a_mixed;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B12_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int=a_mixed
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B13_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B13_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B13_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_nested);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B13_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_nested)
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B13_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B13_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B13_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_nested)
+SELECT a_int
+FROM t1;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B13_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=a_nested)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B13_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B13_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_float=a_str;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B14_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_float=a_str
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_str);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B14_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_str)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B14_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=a_str;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B14_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=a_str
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B14_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_str)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B14_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_str)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B14_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_float=a_str;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B14_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_float=a_str
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_float=a_null;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B15_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_float=a_null
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B15_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_null);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B15_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_null)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B15_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=a_null;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B15_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=a_null
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B15_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_null)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B15_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_null)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B15_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_float=a_null;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B15_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_float=a_null
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B16_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_float=a_empty;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B16_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_float=a_empty
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B16_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_empty);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B16_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_empty)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B16_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=a_empty;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B16_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=a_empty
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B16_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_empty)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B16_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_empty)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B16_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_float=a_empty;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B16_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_float=a_empty
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_float=a_mixed;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B17_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_float=a_mixed
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_mixed);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B17_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_mixed)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B17_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=a_mixed;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B17_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=a_mixed
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B17_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_mixed)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B17_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_mixed)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B17_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_float=a_mixed;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B17_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_float=a_mixed
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B18_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_float=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B18_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_float=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B18_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_nested);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B18_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_nested)
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B18_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B18_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B18_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_nested)
+SELECT a_int
+FROM t1;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B18_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=a_nested)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B18_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_float=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B18_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_float=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_str=a_null;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B19_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_str=a_null
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str=a_null);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B19_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str=a_null)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B19_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str=a_null;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B19_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str=a_null
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str=a_null)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B19_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str=a_null)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_str=a_null;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B19_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_str=a_null
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_str=a_empty;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B20_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_str=a_empty
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str=a_empty);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B20_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str=a_empty)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B20_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str=a_empty;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B20_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str=a_empty
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str=a_empty)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B20_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str=a_empty)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_str=a_empty;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B20_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_str=a_empty
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_str=a_mixed;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B21_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_str=a_mixed
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str=a_mixed);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B21_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str=a_mixed)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B21_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str=a_mixed;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B21_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str=a_mixed
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B21_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str=a_mixed)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B21_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str=a_mixed)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B21_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_str=a_mixed;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B21_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_str=a_mixed
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B22_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_str=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B22_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_str=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B22_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str=a_nested);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B22_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str=a_nested)
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B22_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B22_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B22_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str=a_nested)
+SELECT a_int
+FROM t1;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B22_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str=a_nested)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B22_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_str=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B22_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_str=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_null=a_empty;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B23_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_null=a_empty
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_null=a_empty);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B23_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_null=a_empty)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B23_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_null=a_empty;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B23_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_null=a_empty
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B23_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_null=a_empty)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B23_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_null=a_empty)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B23_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_null=a_empty;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B23_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_null=a_empty
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_null=a_mixed;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B24_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_null=a_mixed
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_null=a_mixed);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B24_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_null=a_mixed)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B24_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_null=a_mixed;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B24_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_null=a_mixed
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B24_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_null=a_mixed)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B24_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_null=a_mixed)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B24_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_null=a_mixed;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B24_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_null=a_mixed
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B25_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_null=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B25_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_null=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B25_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_null=a_nested);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B25_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_null=a_nested)
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B25_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_null=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B25_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_null=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B25_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_null=a_nested)
+SELECT a_int
+FROM t1;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B25_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_null=a_nested)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B25_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_null=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B25_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_null=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_empty=a_mixed;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B26_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_empty=a_mixed
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_empty=a_mixed);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B26_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_empty=a_mixed)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B26_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_empty=a_mixed;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B26_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_empty=a_mixed
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B26_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_empty=a_mixed)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B26_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_empty=a_mixed)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B26_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_empty=a_mixed;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B26_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_empty=a_mixed
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B27_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_empty=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B27_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_empty=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B27_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_empty=a_nested);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B27_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_empty=a_nested)
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B27_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_empty=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B27_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_empty=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B27_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_empty=a_nested)
+SELECT a_int
+FROM t1;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B27_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_empty=a_nested)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B27_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_empty=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B27_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_empty=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B28_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_mixed=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B28_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B28_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=a_nested);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B28_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=a_nested)
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B28_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B28_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B28_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=a_nested)
+SELECT a_int
+FROM t1;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B28_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=a_nested)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B28_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_mixed=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A0_B28_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_mixed=a_nested
+GROUP BY a_int;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool=ARRAY[1,
+                   0];
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool=ARRAY[1,
+                   0]
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=ARRAY[1,
+                      0]);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=ARRAY[1,
+                      0])
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=ARRAY[1,
+                   0];
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=ARRAY[1,
+                   0]
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=ARRAY[1,
+                      0])
+SELECT a_bool
+FROM t1;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=ARRAY[1,
+                      0])
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool=ARRAY[1,
+                   0];
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B1_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool=ARRAY[1,
+                   0]
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool=ARRAY[1,
+                   0,
+                   NULL];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool=ARRAY[1,
+                   0,
+                   NULL]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=ARRAY[1,
+                      0,
+                      NULL]);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=ARRAY[1,
+                      0,
+                      NULL])
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=ARRAY[1,
+                   0,
+                   NULL];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=ARRAY[1,
+                   0,
+                   NULL]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=ARRAY[1,
+                      0,
+                      NULL])
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=ARRAY[1,
+                      0,
+                      NULL])
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool=ARRAY[1,
+                   0,
+                   NULL];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B2_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool=ARRAY[1,
+                   0,
+                   NULL]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool=ARRAY[1,
+                   2,
+                   3];
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool=ARRAY[1,
+                   2,
+                   3]
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=ARRAY[1,
+                      2,
+                      3]);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=ARRAY[1,
+                      2,
+                      3])
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=ARRAY[1,
+                   2,
+                   3];
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=ARRAY[1,
+                   2,
+                   3]
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=ARRAY[1,
+                      2,
+                      3])
+SELECT a_bool
+FROM t1;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=ARRAY[1,
+                      2,
+                      3])
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool=ARRAY[1,
+                   2,
+                   3];
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B3_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool=ARRAY[1,
+                   2,
+                   3]
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool=json_value(a_nested, '$[0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=json_value(a_nested, '$[0]' RETURNING boolean array));
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=json_value(a_nested, '$[0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=json_value(a_nested, '$[0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=json_value(a_nested, '$[0]' RETURNING boolean array))
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=json_value(a_nested, '$[0]' RETURNING boolean array))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool=json_value(a_nested, '$[0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B4_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool=json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool=json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=json_value(a_nested, '$[7][0]' RETURNING boolean array));
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=json_value(a_nested, '$[7][0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool=json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=json_value(a_nested, '$[7][0]' RETURNING boolean array))
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool=json_value(a_nested, '$[7][0]' RETURNING boolean array))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool=json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B5_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool=json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>ARRAY[1,
+                       0]);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>ARRAY[1,
+                       0])
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<>ARRAY[1,
+                    0];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<>ARRAY[1,
+                    0]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>ARRAY[1,
+                       0])
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>ARRAY[1,
+                       0])
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool<>ARRAY[1,
+                    0];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B6_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool<>ARRAY[1,
+                    0]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL];
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>ARRAY[1,
+                       0,
+                       NULL]);
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>ARRAY[1,
+                       0,
+                       NULL])
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL];
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>ARRAY[1,
+                       0,
+                       NULL])
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>ARRAY[1,
+                       0,
+                       NULL])
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL];
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B7_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool<>ARRAY[1,
+                    0,
+                    NULL]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    2,
+                    3];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool<>ARRAY[1,
+                    2,
+                    3]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>ARRAY[1,
+                       2,
+                       3]);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>ARRAY[1,
+                       2,
+                       3])
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<>ARRAY[1,
+                    2,
+                    3];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<>ARRAY[1,
+                    2,
+                    3]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>ARRAY[1,
+                       2,
+                       3])
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>ARRAY[1,
+                       2,
+                       3])
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool<>ARRAY[1,
+                    2,
+                    3];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B8_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool<>ARRAY[1,
+                    2,
+                    3]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool<>json_value(a_nested, '$[0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool<>json_value(a_nested, '$[0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>json_value(a_nested, '$[0]' RETURNING boolean array));
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>json_value(a_nested, '$[0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<>json_value(a_nested, '$[0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<>json_value(a_nested, '$[0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>json_value(a_nested, '$[0]' RETURNING boolean array))
+SELECT a_bool
+FROM t1;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>json_value(a_nested, '$[0]' RETURNING boolean array))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool<>json_value(a_nested, '$[0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B9_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool<>json_value(a_nested, '$[0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array));
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array))
+SELECT a_bool
+FROM t1;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B10_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool>ARRAY[1,
+                   0];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool>ARRAY[1,
+                   0]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>ARRAY[1,
+                      0]);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>ARRAY[1,
+                      0])
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>ARRAY[1,
+                   0];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>ARRAY[1,
+                   0]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>ARRAY[1,
+                      0])
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>ARRAY[1,
+                      0])
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool>ARRAY[1,
+                   0];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B11_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool>ARRAY[1,
+                   0]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool>ARRAY[1,
+                   0,
+                   NULL];
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool>ARRAY[1,
+                   0,
+                   NULL]
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>ARRAY[1,
+                      0,
+                      NULL]);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>ARRAY[1,
+                      0,
+                      NULL])
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>ARRAY[1,
+                   0,
+                   NULL];
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>ARRAY[1,
+                   0,
+                   NULL]
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>ARRAY[1,
+                      0,
+                      NULL])
+SELECT a_bool
+FROM t1;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>ARRAY[1,
+                      0,
+                      NULL])
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool>ARRAY[1,
+                   0,
+                   NULL];
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B12_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool>ARRAY[1,
+                   0,
+                   NULL]
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool>ARRAY[1,
+                   2,
+                   3];
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool>ARRAY[1,
+                   2,
+                   3]
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>ARRAY[1,
+                      2,
+                      3]);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>ARRAY[1,
+                      2,
+                      3])
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>ARRAY[1,
+                   2,
+                   3];
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>ARRAY[1,
+                   2,
+                   3]
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>ARRAY[1,
+                      2,
+                      3])
+SELECT a_bool
+FROM t1;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>ARRAY[1,
+                      2,
+                      3])
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool>ARRAY[1,
+                   2,
+                   3];
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B13_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool>ARRAY[1,
+                   2,
+                   3]
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool>json_value(a_nested, '$[0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool>json_value(a_nested, '$[0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>json_value(a_nested, '$[0]' RETURNING boolean array));
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>json_value(a_nested, '$[0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>json_value(a_nested, '$[0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>json_value(a_nested, '$[0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>json_value(a_nested, '$[0]' RETURNING boolean array))
+SELECT a_bool
+FROM t1;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>json_value(a_nested, '$[0]' RETURNING boolean array))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool>json_value(a_nested, '$[0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B14_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool>json_value(a_nested, '$[0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool>json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool>json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>json_value(a_nested, '$[7][0]' RETURNING boolean array));
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>json_value(a_nested, '$[7][0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>json_value(a_nested, '$[7][0]' RETURNING boolean array))
+SELECT a_bool
+FROM t1;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>json_value(a_nested, '$[7][0]' RETURNING boolean array))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool>json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B15_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool>json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool>=ARRAY[1,
+                    0];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool>=ARRAY[1,
+                    0]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=ARRAY[1,
+                       0]);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=ARRAY[1,
+                       0])
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>=ARRAY[1,
+                    0];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>=ARRAY[1,
+                    0]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=ARRAY[1,
+                       0])
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=ARRAY[1,
+                       0])
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool>=ARRAY[1,
+                    0];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B16_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool>=ARRAY[1,
+                    0]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool>=ARRAY[1,
+                    0,
+                    NULL];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool>=ARRAY[1,
+                    0,
+                    NULL]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=ARRAY[1,
+                       0,
+                       NULL]);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=ARRAY[1,
+                       0,
+                       NULL])
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>=ARRAY[1,
+                    0,
+                    NULL];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>=ARRAY[1,
+                    0,
+                    NULL]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=ARRAY[1,
+                       0,
+                       NULL])
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=ARRAY[1,
+                       0,
+                       NULL])
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool>=ARRAY[1,
+                    0,
+                    NULL];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B17_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool>=ARRAY[1,
+                    0,
+                    NULL]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool>=ARRAY[1,
+                    2,
+                    3];
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool>=ARRAY[1,
+                    2,
+                    3]
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=ARRAY[1,
+                       2,
+                       3]);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=ARRAY[1,
+                       2,
+                       3])
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>=ARRAY[1,
+                    2,
+                    3];
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>=ARRAY[1,
+                    2,
+                    3]
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=ARRAY[1,
+                       2,
+                       3])
+SELECT a_bool
+FROM t1;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=ARRAY[1,
+                       2,
+                       3])
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool>=ARRAY[1,
+                    2,
+                    3];
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B18_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool>=ARRAY[1,
+                    2,
+                    3]
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool>=json_value(a_nested, '$[0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool>=json_value(a_nested, '$[0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=json_value(a_nested, '$[0]' RETURNING boolean array));
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=json_value(a_nested, '$[0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>=json_value(a_nested, '$[0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>=json_value(a_nested, '$[0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=json_value(a_nested, '$[0]' RETURNING boolean array))
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=json_value(a_nested, '$[0]' RETURNING boolean array))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool>=json_value(a_nested, '$[0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B19_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool>=json_value(a_nested, '$[0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array));
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array))
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B20_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool<ARRAY[1,
+                   0];
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool<ARRAY[1,
+                   0]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<ARRAY[1,
+                      0]);
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<ARRAY[1,
+                      0])
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<ARRAY[1,
+                   0];
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<ARRAY[1,
+                   0]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<ARRAY[1,
+                      0])
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<ARRAY[1,
+                      0])
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool<ARRAY[1,
+                   0];
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B21_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool<ARRAY[1,
+                   0]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool<ARRAY[1,
+                   0,
+                   NULL];
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool<ARRAY[1,
+                   0,
+                   NULL]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<ARRAY[1,
+                      0,
+                      NULL]);
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<ARRAY[1,
+                      0,
+                      NULL])
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<ARRAY[1,
+                   0,
+                   NULL];
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<ARRAY[1,
+                   0,
+                   NULL]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<ARRAY[1,
+                      0,
+                      NULL])
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<ARRAY[1,
+                      0,
+                      NULL])
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool<ARRAY[1,
+                   0,
+                   NULL];
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B22_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool<ARRAY[1,
+                   0,
+                   NULL]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool<ARRAY[1,
+                   2,
+                   3];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool<ARRAY[1,
+                   2,
+                   3]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<ARRAY[1,
+                      2,
+                      3]);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<ARRAY[1,
+                      2,
+                      3])
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<ARRAY[1,
+                   2,
+                   3];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<ARRAY[1,
+                   2,
+                   3]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<ARRAY[1,
+                      2,
+                      3])
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<ARRAY[1,
+                      2,
+                      3])
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool<ARRAY[1,
+                   2,
+                   3];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B23_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool<ARRAY[1,
+                   2,
+                   3]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool<json_value(a_nested, '$[0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<json_value(a_nested, '$[0]' RETURNING boolean array));
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<json_value(a_nested, '$[0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<json_value(a_nested, '$[0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<json_value(a_nested, '$[0]' RETURNING boolean array))
+SELECT a_bool
+FROM t1;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<json_value(a_nested, '$[0]' RETURNING boolean array))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool<json_value(a_nested, '$[0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B24_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool<json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool<json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<json_value(a_nested, '$[7][0]' RETURNING boolean array));
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<json_value(a_nested, '$[7][0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<json_value(a_nested, '$[7][0]' RETURNING boolean array))
+SELECT a_bool
+FROM t1;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<json_value(a_nested, '$[7][0]' RETURNING boolean array))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool<json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B25_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool<json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool<=ARRAY[1,
+                    0];
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool<=ARRAY[1,
+                    0]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=ARRAY[1,
+                       0]);
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=ARRAY[1,
+                       0])
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<=ARRAY[1,
+                    0];
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<=ARRAY[1,
+                    0]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=ARRAY[1,
+                       0])
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=ARRAY[1,
+                       0])
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool<=ARRAY[1,
+                    0];
++--------------+
+| a_bool       |
++--------------+
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B26_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool<=ARRAY[1,
+                    0]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool<=ARRAY[1,
+                    0,
+                    NULL];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool<=ARRAY[1,
+                    0,
+                    NULL]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=ARRAY[1,
+                       0,
+                       NULL]);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=ARRAY[1,
+                       0,
+                       NULL])
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<=ARRAY[1,
+                    0,
+                    NULL];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<=ARRAY[1,
+                    0,
+                    NULL]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=ARRAY[1,
+                       0,
+                       NULL])
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=ARRAY[1,
+                       0,
+                       NULL])
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool<=ARRAY[1,
+                    0,
+                    NULL];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B27_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool<=ARRAY[1,
+                    0,
+                    NULL]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool<=ARRAY[1,
+                    2,
+                    3];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool<=ARRAY[1,
+                    2,
+                    3]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=ARRAY[1,
+                       2,
+                       3]);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=ARRAY[1,
+                       2,
+                       3])
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<=ARRAY[1,
+                    2,
+                    3];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<=ARRAY[1,
+                    2,
+                    3]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=ARRAY[1,
+                       2,
+                       3])
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=ARRAY[1,
+                       2,
+                       3])
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool<=ARRAY[1,
+                    2,
+                    3];
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B28_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool<=ARRAY[1,
+                    2,
+                    3]
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array));
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array))
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B29_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool<=json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool<=json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=json_value(a_nested, '$[7][0]' RETURNING boolean array));
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=json_value(a_nested, '$[7][0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<=json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<=json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=json_value(a_nested, '$[7][0]' RETURNING boolean array))
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=json_value(a_nested, '$[7][0]' RETURNING boolean array))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool<=json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B30_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool<=json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array)
+  OR a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array)
+  AND NOT (a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+           AND a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array));
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array)
+  OR a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array)
+  AND NOT (a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+           AND a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array)
+     OR a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array)
+     AND NOT (a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+              AND a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array)));
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array)
+     OR a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array)
+     AND NOT (a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+              AND a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array)))
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array)
+  OR a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array)
+  AND NOT (a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+           AND a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array));
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array)
+  OR a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array)
+  AND NOT (a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+           AND a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array)
+     OR a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array)
+     AND NOT (a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+              AND a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array)))
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array)
+     OR a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array)
+     AND NOT (a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+              AND a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array)))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array)
+  OR a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array)
+  AND NOT (a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+           AND a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array));
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B31_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array)
+  OR a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array)
+  AND NOT (a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+           AND a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE NOT (a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array))
+  OR NOT (a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array))
+  OR a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+  OR a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE NOT (a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array))
+  OR NOT (a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array))
+  OR a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+  OR a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array))
+     OR NOT (a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array))
+     OR a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+     OR a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array));
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array))
+     OR NOT (a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array))
+     OR a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+     OR a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE NOT (a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array))
+  OR NOT (a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array))
+  OR a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+  OR a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE NOT (a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array))
+  OR NOT (a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array))
+  OR a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+  OR a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array))
+     OR NOT (a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array))
+     OR a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+     OR a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array))
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array))
+     OR NOT (a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array))
+     OR a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+     OR a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE NOT (a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array))
+  OR NOT (a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array))
+  OR a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+  OR a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B32_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE NOT (a_bool<=json_value(a_nested, '$[0]' RETURNING boolean array))
+  OR NOT (a_bool>=json_value(a_nested, '$[7][0]' RETURNING boolean array))
+  OR a_bool=json_value(a_nested, '$[0]' RETURNING boolean array)
+  OR a_bool<>json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool IS NULL;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool IS NULL
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool IS NULL);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool IS NULL)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool IS NULL;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool IS NULL
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool IS NULL)
+SELECT a_bool
+FROM t1;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool IS NULL)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool IS NULL;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B33_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool IS NULL
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool IS NOT NULL;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool IS NOT NULL
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool IS NOT NULL);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool IS NOT NULL)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool IS NOT NULL;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool IS NOT NULL
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool IS NOT NULL)
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool IS NOT NULL)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool IS NOT NULL;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B34_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool IS NOT NULL
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS TRUE;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS TRUE
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS TRUE);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS TRUE)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS TRUE;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS TRUE
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS TRUE)
+SELECT a_bool
+FROM t1;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS TRUE)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS TRUE;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B35_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS TRUE
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT TRUE;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT TRUE
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT TRUE);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT TRUE)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT TRUE;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT TRUE
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT TRUE)
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT TRUE)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT TRUE;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B36_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT TRUE
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS FALSE;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS FALSE
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS FALSE);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS FALSE)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS FALSE;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS FALSE
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS FALSE)
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS FALSE)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS FALSE;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B37_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS FALSE
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT FALSE;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT FALSE
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT FALSE);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT FALSE)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT FALSE;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT FALSE
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT FALSE)
+SELECT a_bool
+FROM t1;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT FALSE)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT FALSE;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B38_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE (a_bool<json_value(a_nested, '$[0]' RETURNING boolean array)) IS NOT FALSE
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array));
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array))
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B39_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool NOT BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool NOT BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool NOT BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array));
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool NOT BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool NOT BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool NOT BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool NOT BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array))
+SELECT a_bool
+FROM t1;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool NOT BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool NOT BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array);
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B40_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool NOT BETWEEN json_value(a_nested, '$[0]' RETURNING boolean array) AND json_value(a_nested, '$[7][0]' RETURNING boolean array)
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE array_to_string(a_bool, ',') like '%';
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE array_to_string(a_bool, ',') like '%'
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_bool, ',') like '%');
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_bool, ',') like '%')
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(a_bool, ',') like '%';
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(a_bool, ',') like '%'
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_bool, ',') like '%')
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_bool, ',') like '%')
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE array_to_string(a_bool, ',') like '%';
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B41_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE array_to_string(a_bool, ',') like '%'
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE array_to_string(json_value(a_nested, '$[0]' RETURNING boolean array), ',') not like '%';
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE array_to_string(json_value(a_nested, '$[0]' RETURNING boolean array), ',') not like '%'
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[0]' RETURNING boolean array), ',') not like '%');
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[0]' RETURNING boolean array), ',') not like '%')
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(json_value(a_nested, '$[0]' RETURNING boolean array), ',') not like '%';
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(json_value(a_nested, '$[0]' RETURNING boolean array), ',') not like '%'
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[0]' RETURNING boolean array), ',') not like '%')
+SELECT a_bool
+FROM t1;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[0]' RETURNING boolean array), ',') not like '%')
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE array_to_string(json_value(a_nested, '$[0]' RETURNING boolean array), ',') not like '%';
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B42_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE array_to_string(json_value(a_nested, '$[0]' RETURNING boolean array), ',') not like '%'
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                 json_value(a_nested, '$[7][0]' RETURNING boolean array));
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                 json_value(a_nested, '$[7][0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                    json_value(a_nested, '$[7][0]' RETURNING boolean array)));
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                    json_value(a_nested, '$[7][0]' RETURNING boolean array)))
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                 json_value(a_nested, '$[7][0]' RETURNING boolean array));
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                 json_value(a_nested, '$[7][0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                    json_value(a_nested, '$[7][0]' RETURNING boolean array)))
+SELECT a_bool
+FROM t1;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                    json_value(a_nested, '$[7][0]' RETURNING boolean array)))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                 json_value(a_nested, '$[7][0]' RETURNING boolean array));
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B43_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                 json_value(a_nested, '$[7][0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------------+-----+
+| a_bool       | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool NOT IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                     json_value(a_nested, '$[7][0]' RETURNING boolean array));
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool NOT IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                     json_value(a_nested, '$[7][0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool NOT IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                        json_value(a_nested, '$[7][0]' RETURNING boolean array)));
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool NOT IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                        json_value(a_nested, '$[7][0]' RETURNING boolean array)))
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool NOT IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                     json_value(a_nested, '$[7][0]' RETURNING boolean array));
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool NOT IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                     json_value(a_nested, '$[7][0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool NOT IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                        json_value(a_nested, '$[7][0]' RETURNING boolean array)))
+SELECT a_bool
+FROM t1;
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool NOT IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                        json_value(a_nested, '$[7][0]' RETURNING boolean array)))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool NOT IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                     json_value(a_nested, '$[7][0]' RETURNING boolean array));
++--------+
+| a_bool |
++--------+
++--------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B44_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool NOT IN (json_value(a_nested, '$[0]' RETURNING boolean array),
+                     json_value(a_nested, '$[7][0]' RETURNING boolean array))
+GROUP BY a_bool;
++--------+-----+
+| a_bool | cnt |
++--------+-----+
++--------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool IN
+    (SELECT a_bool
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool IN
+    (SELECT a_bool
+     FROM test_array)
+GROUP BY a_bool;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool IN
+       (SELECT a_bool
+        FROM test_array));
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool IN
+       (SELECT a_bool
+        FROM test_array))
+GROUP BY a_bool;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool IN
+    (SELECT a_bool
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool IN
+    (SELECT a_bool
+     FROM test_array)
+GROUP BY a_bool;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool IN
+       (SELECT a_bool
+        FROM test_array))
+SELECT a_bool
+FROM t1;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool IN
+       (SELECT a_bool
+        FROM test_array))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool IN
+    (SELECT a_bool
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B45_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool IN
+    (SELECT a_bool
+     FROM test_array)
+GROUP BY a_bool;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM test_array
+WHERE a_bool NOT IN
+    (SELECT a_bool
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM test_array
+WHERE a_bool NOT IN
+    (SELECT a_bool
+     FROM test_array)
+GROUP BY a_bool;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool NOT IN
+       (SELECT a_bool
+        FROM test_array));
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_bool NOT IN
+       (SELECT a_bool
+        FROM test_array))
+GROUP BY a_bool;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool NOT IN
+    (SELECT a_bool
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_bool NOT IN
+    (SELECT a_bool
+     FROM test_array)
+GROUP BY a_bool;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool NOT IN
+       (SELECT a_bool
+        FROM test_array))
+SELECT a_bool
+FROM t1;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_bool NOT IN
+       (SELECT a_bool
+        FROM test_array))
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+GROUP BY a_bool;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool
+FROM t1
+WHERE a_bool NOT IN
+    (SELECT a_bool
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A1_B46_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_bool,
+       count(*) cnt
+FROM t1
+WHERE a_bool NOT IN
+    (SELECT a_bool
+     FROM test_array)
+GROUP BY a_bool;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int=ARRAY[1,
+                  2];
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int=ARRAY[1,
+                  2]
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=ARRAY[1,
+                     2]);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=ARRAY[1,
+                     2])
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=ARRAY[1,
+                  2];
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=ARRAY[1,
+                  2]
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=ARRAY[1,
+                     2])
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=ARRAY[1,
+                     2])
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int=ARRAY[1,
+                  2];
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B1_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int=ARRAY[1,
+                  2]
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int=ARRAY[1,
+                  2,
+                  NULL];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int=ARRAY[1,
+                  2,
+                  NULL]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=ARRAY[1,
+                     2,
+                     NULL]);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=ARRAY[1,
+                     2,
+                     NULL])
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=ARRAY[1,
+                  2,
+                  NULL];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=ARRAY[1,
+                  2,
+                  NULL]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=ARRAY[1,
+                     2,
+                     NULL])
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=ARRAY[1,
+                     2,
+                     NULL])
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int=ARRAY[1,
+                  2,
+                  NULL];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B2_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int=ARRAY[1,
+                  2,
+                  NULL]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int=ARRAY[1,
+                  2,
+                  3];
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int=ARRAY[1,
+                  2,
+                  3]
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=ARRAY[1,
+                     2,
+                     3]);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=ARRAY[1,
+                     2,
+                     3])
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=ARRAY[1,
+                  2,
+                  3];
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=ARRAY[1,
+                  2,
+                  3]
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=ARRAY[1,
+                     2,
+                     3])
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=ARRAY[1,
+                     2,
+                     3])
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int=ARRAY[1,
+                  2,
+                  3];
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B3_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int=ARRAY[1,
+                  2,
+                  3]
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int=json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=json_value(a_nested, '$[1]' RETURNING bigint array));
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=json_value(a_nested, '$[1]' RETURNING bigint array))
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=json_value(a_nested, '$[1]' RETURNING bigint array))
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=json_value(a_nested, '$[1]' RETURNING bigint array))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int=json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B4_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int=json_value(a_nested, '$[7][1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int=json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=json_value(a_nested, '$[7][1]' RETURNING bigint array));
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int=json_value(a_nested, '$[7][1]' RETURNING bigint array))
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=json_value(a_nested, '$[7][1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int=json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=json_value(a_nested, '$[7][1]' RETURNING bigint array))
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int=json_value(a_nested, '$[7][1]' RETURNING bigint array))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int=json_value(a_nested, '$[7][1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B5_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int=json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>ARRAY[1,
+                      2]);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>ARRAY[1,
+                      2])
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<>ARRAY[1,
+                   2];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<>ARRAY[1,
+                   2]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>ARRAY[1,
+                      2])
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>ARRAY[1,
+                      2])
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int<>ARRAY[1,
+                   2];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B6_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int<>ARRAY[1,
+                   2]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL];
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>ARRAY[1,
+                      2,
+                      NULL]);
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>ARRAY[1,
+                      2,
+                      NULL])
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL];
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>ARRAY[1,
+                      2,
+                      NULL])
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>ARRAY[1,
+                      2,
+                      NULL])
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL];
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B7_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int<>ARRAY[1,
+                   2,
+                   NULL]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   3];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int<>ARRAY[1,
+                   2,
+                   3]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>ARRAY[1,
+                      2,
+                      3]);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>ARRAY[1,
+                      2,
+                      3])
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<>ARRAY[1,
+                   2,
+                   3];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<>ARRAY[1,
+                   2,
+                   3]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>ARRAY[1,
+                      2,
+                      3])
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>ARRAY[1,
+                      2,
+                      3])
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int<>ARRAY[1,
+                   2,
+                   3];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B8_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int<>ARRAY[1,
+                   2,
+                   3]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int<>json_value(a_nested, '$[1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int<>json_value(a_nested, '$[1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>json_value(a_nested, '$[1]' RETURNING bigint array));
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>json_value(a_nested, '$[1]' RETURNING bigint array))
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<>json_value(a_nested, '$[1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<>json_value(a_nested, '$[1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>json_value(a_nested, '$[1]' RETURNING bigint array))
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>json_value(a_nested, '$[1]' RETURNING bigint array))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int<>json_value(a_nested, '$[1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B9_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int<>json_value(a_nested, '$[1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array));
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array))
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array))
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B10_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int>ARRAY[1,
+                  2];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int>ARRAY[1,
+                  2]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>ARRAY[1,
+                     2]);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>ARRAY[1,
+                     2])
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>ARRAY[1,
+                  2];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>ARRAY[1,
+                  2]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>ARRAY[1,
+                     2])
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>ARRAY[1,
+                     2])
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int>ARRAY[1,
+                  2];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B11_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int>ARRAY[1,
+                  2]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int>ARRAY[1,
+                  2,
+                  NULL];
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int>ARRAY[1,
+                  2,
+                  NULL]
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>ARRAY[1,
+                     2,
+                     NULL]);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>ARRAY[1,
+                     2,
+                     NULL])
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>ARRAY[1,
+                  2,
+                  NULL];
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>ARRAY[1,
+                  2,
+                  NULL]
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>ARRAY[1,
+                     2,
+                     NULL])
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>ARRAY[1,
+                     2,
+                     NULL])
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int>ARRAY[1,
+                  2,
+                  NULL];
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B12_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int>ARRAY[1,
+                  2,
+                  NULL]
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int>ARRAY[1,
+                  2,
+                  3];
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int>ARRAY[1,
+                  2,
+                  3]
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>ARRAY[1,
+                     2,
+                     3]);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>ARRAY[1,
+                     2,
+                     3])
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>ARRAY[1,
+                  2,
+                  3];
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>ARRAY[1,
+                  2,
+                  3]
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>ARRAY[1,
+                     2,
+                     3])
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>ARRAY[1,
+                     2,
+                     3])
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int>ARRAY[1,
+                  2,
+                  3];
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B13_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int>ARRAY[1,
+                  2,
+                  3]
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int>json_value(a_nested, '$[1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int>json_value(a_nested, '$[1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>json_value(a_nested, '$[1]' RETURNING bigint array));
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>json_value(a_nested, '$[1]' RETURNING bigint array))
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>json_value(a_nested, '$[1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>json_value(a_nested, '$[1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>json_value(a_nested, '$[1]' RETURNING bigint array))
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>json_value(a_nested, '$[1]' RETURNING bigint array))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int>json_value(a_nested, '$[1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B14_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int>json_value(a_nested, '$[1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int>json_value(a_nested, '$[7][1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int>json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>json_value(a_nested, '$[7][1]' RETURNING bigint array));
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>json_value(a_nested, '$[7][1]' RETURNING bigint array))
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>json_value(a_nested, '$[7][1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>json_value(a_nested, '$[7][1]' RETURNING bigint array))
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>json_value(a_nested, '$[7][1]' RETURNING bigint array))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int>json_value(a_nested, '$[7][1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B15_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int>json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int>=ARRAY[1,
+                   2];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int>=ARRAY[1,
+                   2]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=ARRAY[1,
+                      2]);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=ARRAY[1,
+                      2])
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>=ARRAY[1,
+                   2];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>=ARRAY[1,
+                   2]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=ARRAY[1,
+                      2])
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=ARRAY[1,
+                      2])
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int>=ARRAY[1,
+                   2];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B16_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int>=ARRAY[1,
+                   2]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int>=ARRAY[1,
+                   2,
+                   NULL];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int>=ARRAY[1,
+                   2,
+                   NULL]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=ARRAY[1,
+                      2,
+                      NULL]);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=ARRAY[1,
+                      2,
+                      NULL])
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>=ARRAY[1,
+                   2,
+                   NULL];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>=ARRAY[1,
+                   2,
+                   NULL]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=ARRAY[1,
+                      2,
+                      NULL])
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=ARRAY[1,
+                      2,
+                      NULL])
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int>=ARRAY[1,
+                   2,
+                   NULL];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B17_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int>=ARRAY[1,
+                   2,
+                   NULL]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int>=ARRAY[1,
+                   2,
+                   3];
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int>=ARRAY[1,
+                   2,
+                   3]
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=ARRAY[1,
+                      2,
+                      3]);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=ARRAY[1,
+                      2,
+                      3])
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>=ARRAY[1,
+                   2,
+                   3];
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>=ARRAY[1,
+                   2,
+                   3]
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=ARRAY[1,
+                      2,
+                      3])
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=ARRAY[1,
+                      2,
+                      3])
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int>=ARRAY[1,
+                   2,
+                   3];
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B18_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int>=ARRAY[1,
+                   2,
+                   3]
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int>=json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int>=json_value(a_nested, '$[1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=json_value(a_nested, '$[1]' RETURNING bigint array));
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=json_value(a_nested, '$[1]' RETURNING bigint array))
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>=json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>=json_value(a_nested, '$[1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=json_value(a_nested, '$[1]' RETURNING bigint array))
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=json_value(a_nested, '$[1]' RETURNING bigint array))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int>=json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B19_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int>=json_value(a_nested, '$[1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array));
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array))
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array))
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B20_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int<ARRAY[1,
+                  2];
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int<ARRAY[1,
+                  2]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<ARRAY[1,
+                     2]);
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<ARRAY[1,
+                     2])
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<ARRAY[1,
+                  2];
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<ARRAY[1,
+                  2]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<ARRAY[1,
+                     2])
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<ARRAY[1,
+                     2])
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int<ARRAY[1,
+                  2];
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B21_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int<ARRAY[1,
+                  2]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int<ARRAY[1,
+                  2,
+                  NULL];
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int<ARRAY[1,
+                  2,
+                  NULL]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<ARRAY[1,
+                     2,
+                     NULL]);
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<ARRAY[1,
+                     2,
+                     NULL])
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<ARRAY[1,
+                  2,
+                  NULL];
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<ARRAY[1,
+                  2,
+                  NULL]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<ARRAY[1,
+                     2,
+                     NULL])
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<ARRAY[1,
+                     2,
+                     NULL])
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int<ARRAY[1,
+                  2,
+                  NULL];
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B22_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int<ARRAY[1,
+                  2,
+                  NULL]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int<ARRAY[1,
+                  2,
+                  3];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int<ARRAY[1,
+                  2,
+                  3]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<ARRAY[1,
+                     2,
+                     3]);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<ARRAY[1,
+                     2,
+                     3])
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<ARRAY[1,
+                  2,
+                  3];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<ARRAY[1,
+                  2,
+                  3]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<ARRAY[1,
+                     2,
+                     3])
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<ARRAY[1,
+                     2,
+                     3])
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int<ARRAY[1,
+                  2,
+                  3];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B23_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int<ARRAY[1,
+                  2,
+                  3]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int<json_value(a_nested, '$[1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int<json_value(a_nested, '$[1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<json_value(a_nested, '$[1]' RETURNING bigint array));
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<json_value(a_nested, '$[1]' RETURNING bigint array))
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<json_value(a_nested, '$[1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<json_value(a_nested, '$[1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<json_value(a_nested, '$[1]' RETURNING bigint array))
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<json_value(a_nested, '$[1]' RETURNING bigint array))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int<json_value(a_nested, '$[1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B24_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int<json_value(a_nested, '$[1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int<json_value(a_nested, '$[7][1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int<json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<json_value(a_nested, '$[7][1]' RETURNING bigint array));
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<json_value(a_nested, '$[7][1]' RETURNING bigint array))
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<json_value(a_nested, '$[7][1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<json_value(a_nested, '$[7][1]' RETURNING bigint array))
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<json_value(a_nested, '$[7][1]' RETURNING bigint array))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int<json_value(a_nested, '$[7][1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B25_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int<json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int<=ARRAY[1,
+                   2];
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int<=ARRAY[1,
+                   2]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=ARRAY[1,
+                      2]);
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=ARRAY[1,
+                      2])
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<=ARRAY[1,
+                   2];
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<=ARRAY[1,
+                   2]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=ARRAY[1,
+                      2])
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=ARRAY[1,
+                      2])
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int<=ARRAY[1,
+                   2];
++--------------+
+| a_int        |
++--------------+
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B26_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int<=ARRAY[1,
+                   2]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int<=ARRAY[1,
+                   2,
+                   NULL];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int<=ARRAY[1,
+                   2,
+                   NULL]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=ARRAY[1,
+                      2,
+                      NULL]);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=ARRAY[1,
+                      2,
+                      NULL])
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<=ARRAY[1,
+                   2,
+                   NULL];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<=ARRAY[1,
+                   2,
+                   NULL]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=ARRAY[1,
+                      2,
+                      NULL])
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=ARRAY[1,
+                      2,
+                      NULL])
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int<=ARRAY[1,
+                   2,
+                   NULL];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B27_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int<=ARRAY[1,
+                   2,
+                   NULL]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int<=ARRAY[1,
+                   2,
+                   3];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int<=ARRAY[1,
+                   2,
+                   3]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=ARRAY[1,
+                      2,
+                      3]);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=ARRAY[1,
+                      2,
+                      3])
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<=ARRAY[1,
+                   2,
+                   3];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<=ARRAY[1,
+                   2,
+                   3]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=ARRAY[1,
+                      2,
+                      3])
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=ARRAY[1,
+                      2,
+                      3])
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int<=ARRAY[1,
+                   2,
+                   3];
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B28_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int<=ARRAY[1,
+                   2,
+                   3]
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array));
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array))
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array))
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B29_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int<=json_value(a_nested, '$[7][1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int<=json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=json_value(a_nested, '$[7][1]' RETURNING bigint array));
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=json_value(a_nested, '$[7][1]' RETURNING bigint array))
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<=json_value(a_nested, '$[7][1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<=json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=json_value(a_nested, '$[7][1]' RETURNING bigint array))
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=json_value(a_nested, '$[7][1]' RETURNING bigint array))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int<=json_value(a_nested, '$[7][1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B30_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int<=json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array)
+  OR a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array)
+  AND NOT (a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+           AND a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array));
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array)
+  OR a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array)
+  AND NOT (a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+           AND a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array))
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array)
+     OR a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array)
+     AND NOT (a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+              AND a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array)));
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array)
+     OR a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array)
+     AND NOT (a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+              AND a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array)))
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array)
+  OR a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array)
+  AND NOT (a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+           AND a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array));
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array)
+  OR a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array)
+  AND NOT (a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+           AND a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array))
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array)
+     OR a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array)
+     AND NOT (a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+              AND a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array)))
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array)
+     OR a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array)
+     AND NOT (a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+              AND a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array)))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array)
+  OR a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array)
+  AND NOT (a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+           AND a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array));
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B31_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int<=json_value(a_nested, '$[1]' RETURNING bigint array)
+  OR a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array)
+  AND NOT (a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+           AND a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array))
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE NOT (a_int<=json_value(a_nested, '$[1]' RETURNING bigint array))
+  OR NOT (a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array))
+  OR a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+  OR a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE NOT (a_int<=json_value(a_nested, '$[1]' RETURNING bigint array))
+  OR NOT (a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array))
+  OR a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+  OR a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_int<=json_value(a_nested, '$[1]' RETURNING bigint array))
+     OR NOT (a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array))
+     OR a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+     OR a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array));
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_int<=json_value(a_nested, '$[1]' RETURNING bigint array))
+     OR NOT (a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array))
+     OR a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+     OR a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array))
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE NOT (a_int<=json_value(a_nested, '$[1]' RETURNING bigint array))
+  OR NOT (a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array))
+  OR a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+  OR a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE NOT (a_int<=json_value(a_nested, '$[1]' RETURNING bigint array))
+  OR NOT (a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array))
+  OR a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+  OR a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_int<=json_value(a_nested, '$[1]' RETURNING bigint array))
+     OR NOT (a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array))
+     OR a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+     OR a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array))
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_int<=json_value(a_nested, '$[1]' RETURNING bigint array))
+     OR NOT (a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array))
+     OR a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+     OR a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE NOT (a_int<=json_value(a_nested, '$[1]' RETURNING bigint array))
+  OR NOT (a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array))
+  OR a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+  OR a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B32_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE NOT (a_int<=json_value(a_nested, '$[1]' RETURNING bigint array))
+  OR NOT (a_int>=json_value(a_nested, '$[7][1]' RETURNING bigint array))
+  OR a_int=json_value(a_nested, '$[1]' RETURNING bigint array)
+  OR a_int<>json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int IS NULL;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int IS NULL
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int IS NULL);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int IS NULL)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int IS NULL;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int IS NULL
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int IS NULL)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int IS NULL)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int IS NULL;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B33_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int IS NULL
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int IS NOT NULL;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int IS NOT NULL
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int IS NOT NULL);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int IS NOT NULL)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int IS NOT NULL;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int IS NOT NULL
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int IS NOT NULL)
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int IS NOT NULL)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int IS NOT NULL;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B34_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int IS NOT NULL
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS TRUE;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS TRUE
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS TRUE);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS TRUE)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS TRUE;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS TRUE
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS TRUE)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS TRUE)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS TRUE;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B35_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS TRUE
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT TRUE;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT TRUE
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT TRUE);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT TRUE)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT TRUE;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT TRUE
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT TRUE)
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT TRUE)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT TRUE;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B36_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT TRUE
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS FALSE;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS FALSE
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS FALSE);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS FALSE)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS FALSE;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS FALSE
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS FALSE)
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS FALSE)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS FALSE;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B37_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS FALSE
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT FALSE;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT FALSE
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT FALSE);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT FALSE)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT FALSE;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT FALSE
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT FALSE)
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT FALSE)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT FALSE;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B38_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE (a_int<json_value(a_nested, '$[1]' RETURNING bigint array)) IS NOT FALSE
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array));
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array))
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array))
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B39_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int NOT BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int NOT BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int NOT BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array));
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int NOT BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array))
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int NOT BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int NOT BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int NOT BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array))
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int NOT BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int NOT BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array);
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B40_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int NOT BETWEEN json_value(a_nested, '$[1]' RETURNING bigint array) AND json_value(a_nested, '$[7][1]' RETURNING bigint array)
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE array_to_string(a_int, ',') like '%';
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE array_to_string(a_int, ',') like '%'
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_int, ',') like '%');
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_int, ',') like '%')
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(a_int, ',') like '%';
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(a_int, ',') like '%'
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_int, ',') like '%')
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_int, ',') like '%')
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE array_to_string(a_int, ',') like '%';
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B41_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE array_to_string(a_int, ',') like '%'
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE array_to_string(json_value(a_nested, '$[1]' RETURNING bigint array), ',') not like '%';
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE array_to_string(json_value(a_nested, '$[1]' RETURNING bigint array), ',') not like '%'
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[1]' RETURNING bigint array), ',') not like '%');
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[1]' RETURNING bigint array), ',') not like '%')
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(json_value(a_nested, '$[1]' RETURNING bigint array), ',') not like '%';
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(json_value(a_nested, '$[1]' RETURNING bigint array), ',') not like '%'
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[1]' RETURNING bigint array), ',') not like '%')
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[1]' RETURNING bigint array), ',') not like '%')
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE array_to_string(json_value(a_nested, '$[1]' RETURNING bigint array), ',') not like '%';
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B42_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE array_to_string(json_value(a_nested, '$[1]' RETURNING bigint array), ',') not like '%'
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                json_value(a_nested, '$[7][1]' RETURNING bigint array));
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                json_value(a_nested, '$[7][1]' RETURNING bigint array))
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                   json_value(a_nested, '$[7][1]' RETURNING bigint array)));
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                   json_value(a_nested, '$[7][1]' RETURNING bigint array)))
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                json_value(a_nested, '$[7][1]' RETURNING bigint array));
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                json_value(a_nested, '$[7][1]' RETURNING bigint array))
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                   json_value(a_nested, '$[7][1]' RETURNING bigint array)))
+SELECT a_int
+FROM t1;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                   json_value(a_nested, '$[7][1]' RETURNING bigint array)))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                json_value(a_nested, '$[7][1]' RETURNING bigint array));
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B43_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                json_value(a_nested, '$[7][1]' RETURNING bigint array))
+GROUP BY a_int;
++--------------+-----+
+| a_int        | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int NOT IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                    json_value(a_nested, '$[7][1]' RETURNING bigint array));
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int NOT IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                    json_value(a_nested, '$[7][1]' RETURNING bigint array))
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int NOT IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                       json_value(a_nested, '$[7][1]' RETURNING bigint array)));
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int NOT IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                       json_value(a_nested, '$[7][1]' RETURNING bigint array)))
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int NOT IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                    json_value(a_nested, '$[7][1]' RETURNING bigint array));
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int NOT IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                    json_value(a_nested, '$[7][1]' RETURNING bigint array))
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int NOT IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                       json_value(a_nested, '$[7][1]' RETURNING bigint array)))
+SELECT a_int
+FROM t1;
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int NOT IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                       json_value(a_nested, '$[7][1]' RETURNING bigint array)))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int NOT IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                    json_value(a_nested, '$[7][1]' RETURNING bigint array));
++-------+
+| a_int |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B44_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int NOT IN (json_value(a_nested, '$[1]' RETURNING bigint array),
+                    json_value(a_nested, '$[7][1]' RETURNING bigint array))
+GROUP BY a_int;
++-------+-----+
+| a_int | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int IN
+    (SELECT a_int
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int IN
+    (SELECT a_int
+     FROM test_array)
+GROUP BY a_int;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int IN
+       (SELECT a_int
+        FROM test_array));
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int IN
+       (SELECT a_int
+        FROM test_array))
+GROUP BY a_int;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int IN
+    (SELECT a_int
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int IN
+    (SELECT a_int
+     FROM test_array)
+GROUP BY a_int;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int IN
+       (SELECT a_int
+        FROM test_array))
+SELECT a_int
+FROM t1;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int IN
+       (SELECT a_int
+        FROM test_array))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int IN
+    (SELECT a_int
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B45_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int IN
+    (SELECT a_int
+     FROM test_array)
+GROUP BY a_int;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM test_array
+WHERE a_int NOT IN
+    (SELECT a_int
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM test_array
+WHERE a_int NOT IN
+    (SELECT a_int
+     FROM test_array)
+GROUP BY a_int;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int NOT IN
+       (SELECT a_int
+        FROM test_array));
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_int NOT IN
+       (SELECT a_int
+        FROM test_array))
+GROUP BY a_int;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int NOT IN
+    (SELECT a_int
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_int NOT IN
+    (SELECT a_int
+     FROM test_array)
+GROUP BY a_int;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int NOT IN
+       (SELECT a_int
+        FROM test_array))
+SELECT a_int
+FROM t1;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_int NOT IN
+       (SELECT a_int
+        FROM test_array))
+SELECT a_int,
+       count(*) cnt
+FROM t1
+GROUP BY a_int;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int
+FROM t1
+WHERE a_int NOT IN
+    (SELECT a_int
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A2_B46_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_int,
+       count(*) cnt
+FROM t1
+WHERE a_int NOT IN
+    (SELECT a_int
+     FROM test_array)
+GROUP BY a_int;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float=ARRAY[0.1,
+                    0.2];
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float=ARRAY[0.1,
+                    0.2]
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=ARRAY[0.1,
+                       0.2]);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=ARRAY[0.1,
+                       0.2])
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=ARRAY[0.1,
+                    0.2];
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=ARRAY[0.1,
+                    0.2]
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=ARRAY[0.1,
+                       0.2])
+SELECT a_float
+FROM t1;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=ARRAY[0.1,
+                       0.2])
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float=ARRAY[0.1,
+                    0.2];
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B1_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float=ARRAY[0.1,
+                    0.2]
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float=ARRAY[0.1,
+                    0.2,
+                    NULL];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float=ARRAY[0.1,
+                    0.2,
+                    NULL]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=ARRAY[0.1,
+                       0.2,
+                       NULL]);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=ARRAY[0.1,
+                       0.2,
+                       NULL])
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=ARRAY[0.1,
+                    0.2,
+                    NULL];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=ARRAY[0.1,
+                    0.2,
+                    NULL]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=ARRAY[0.1,
+                       0.2,
+                       NULL])
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=ARRAY[0.1,
+                       0.2,
+                       NULL])
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float=ARRAY[0.1,
+                    0.2,
+                    NULL];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B2_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float=ARRAY[0.1,
+                    0.2,
+                    NULL]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float=ARRAY[0.1,
+                    0.2,
+                    0.3];
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float=ARRAY[0.1,
+                    0.2,
+                    0.3]
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=ARRAY[0.1,
+                       0.2,
+                       0.3]);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=ARRAY[0.1,
+                       0.2,
+                       0.3])
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=ARRAY[0.1,
+                    0.2,
+                    0.3];
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=ARRAY[0.1,
+                    0.2,
+                    0.3]
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=ARRAY[0.1,
+                       0.2,
+                       0.3])
+SELECT a_float
+FROM t1;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=ARRAY[0.1,
+                       0.2,
+                       0.3])
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float=ARRAY[0.1,
+                    0.2,
+                    0.3];
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B3_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float=ARRAY[0.1,
+                    0.2,
+                    0.3]
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float=json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=json_value(a_nested, '$[2]' RETURNING decimal array));
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=json_value(a_nested, '$[2]' RETURNING decimal array))
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=json_value(a_nested, '$[2]' RETURNING decimal array))
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=json_value(a_nested, '$[2]' RETURNING decimal array))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float=json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B4_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float=json_value(a_nested, '$[7][2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float=json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=json_value(a_nested, '$[7][2]' RETURNING decimal array));
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float=json_value(a_nested, '$[7][2]' RETURNING decimal array))
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=json_value(a_nested, '$[7][2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float=json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=json_value(a_nested, '$[7][2]' RETURNING decimal array))
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float=json_value(a_nested, '$[7][2]' RETURNING decimal array))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float=json_value(a_nested, '$[7][2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B5_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float=json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>ARRAY[0.1,
+                        0.2]);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>ARRAY[0.1,
+                        0.2])
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<>ARRAY[0.1,
+                     0.2];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<>ARRAY[0.1,
+                     0.2]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>ARRAY[0.1,
+                        0.2])
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>ARRAY[0.1,
+                        0.2])
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float<>ARRAY[0.1,
+                     0.2];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B6_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float<>ARRAY[0.1,
+                     0.2]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL];
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>ARRAY[0.1,
+                        0.2,
+                        NULL]);
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>ARRAY[0.1,
+                        0.2,
+                        NULL])
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL];
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>ARRAY[0.1,
+                        0.2,
+                        NULL])
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>ARRAY[0.1,
+                        0.2,
+                        NULL])
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL];
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B7_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     NULL]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     0.3];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     0.3]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>ARRAY[0.1,
+                        0.2,
+                        0.3]);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>ARRAY[0.1,
+                        0.2,
+                        0.3])
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     0.3];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     0.3]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>ARRAY[0.1,
+                        0.2,
+                        0.3])
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>ARRAY[0.1,
+                        0.2,
+                        0.3])
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     0.3];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B8_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float<>ARRAY[0.1,
+                     0.2,
+                     0.3]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float<>json_value(a_nested, '$[2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float<>json_value(a_nested, '$[2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>json_value(a_nested, '$[2]' RETURNING decimal array));
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>json_value(a_nested, '$[2]' RETURNING decimal array))
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<>json_value(a_nested, '$[2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<>json_value(a_nested, '$[2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>json_value(a_nested, '$[2]' RETURNING decimal array))
+SELECT a_float
+FROM t1;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>json_value(a_nested, '$[2]' RETURNING decimal array))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float<>json_value(a_nested, '$[2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B9_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float<>json_value(a_nested, '$[2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array));
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array))
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array))
+SELECT a_float
+FROM t1;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B10_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float>ARRAY[0.1,
+                    0.2];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float>ARRAY[0.1,
+                    0.2]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>ARRAY[0.1,
+                       0.2]);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>ARRAY[0.1,
+                       0.2])
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>ARRAY[0.1,
+                    0.2];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>ARRAY[0.1,
+                    0.2]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>ARRAY[0.1,
+                       0.2])
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>ARRAY[0.1,
+                       0.2])
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float>ARRAY[0.1,
+                    0.2];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B11_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float>ARRAY[0.1,
+                    0.2]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float>ARRAY[0.1,
+                    0.2,
+                    NULL];
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float>ARRAY[0.1,
+                    0.2,
+                    NULL]
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>ARRAY[0.1,
+                       0.2,
+                       NULL]);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>ARRAY[0.1,
+                       0.2,
+                       NULL])
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>ARRAY[0.1,
+                    0.2,
+                    NULL];
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>ARRAY[0.1,
+                    0.2,
+                    NULL]
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>ARRAY[0.1,
+                       0.2,
+                       NULL])
+SELECT a_float
+FROM t1;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>ARRAY[0.1,
+                       0.2,
+                       NULL])
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float>ARRAY[0.1,
+                    0.2,
+                    NULL];
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B12_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float>ARRAY[0.1,
+                    0.2,
+                    NULL]
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float>ARRAY[0.1,
+                    0.2,
+                    0.3];
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float>ARRAY[0.1,
+                    0.2,
+                    0.3]
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>ARRAY[0.1,
+                       0.2,
+                       0.3]);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>ARRAY[0.1,
+                       0.2,
+                       0.3])
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>ARRAY[0.1,
+                    0.2,
+                    0.3];
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>ARRAY[0.1,
+                    0.2,
+                    0.3]
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>ARRAY[0.1,
+                       0.2,
+                       0.3])
+SELECT a_float
+FROM t1;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>ARRAY[0.1,
+                       0.2,
+                       0.3])
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float>ARRAY[0.1,
+                    0.2,
+                    0.3];
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B13_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float>ARRAY[0.1,
+                    0.2,
+                    0.3]
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float>json_value(a_nested, '$[2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float>json_value(a_nested, '$[2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>json_value(a_nested, '$[2]' RETURNING decimal array));
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>json_value(a_nested, '$[2]' RETURNING decimal array))
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>json_value(a_nested, '$[2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>json_value(a_nested, '$[2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>json_value(a_nested, '$[2]' RETURNING decimal array))
+SELECT a_float
+FROM t1;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>json_value(a_nested, '$[2]' RETURNING decimal array))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float>json_value(a_nested, '$[2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B14_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float>json_value(a_nested, '$[2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float>json_value(a_nested, '$[7][2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float>json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>json_value(a_nested, '$[7][2]' RETURNING decimal array));
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>json_value(a_nested, '$[7][2]' RETURNING decimal array))
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>json_value(a_nested, '$[7][2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>json_value(a_nested, '$[7][2]' RETURNING decimal array))
+SELECT a_float
+FROM t1;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>json_value(a_nested, '$[7][2]' RETURNING decimal array))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float>json_value(a_nested, '$[7][2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B15_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float>json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float>=ARRAY[0.1,
+                     0.2];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float>=ARRAY[0.1,
+                     0.2]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=ARRAY[0.1,
+                        0.2]);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=ARRAY[0.1,
+                        0.2])
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>=ARRAY[0.1,
+                     0.2];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>=ARRAY[0.1,
+                     0.2]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=ARRAY[0.1,
+                        0.2])
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=ARRAY[0.1,
+                        0.2])
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float>=ARRAY[0.1,
+                     0.2];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B16_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float>=ARRAY[0.1,
+                     0.2]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float>=ARRAY[0.1,
+                     0.2,
+                     NULL];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float>=ARRAY[0.1,
+                     0.2,
+                     NULL]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=ARRAY[0.1,
+                        0.2,
+                        NULL]);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=ARRAY[0.1,
+                        0.2,
+                        NULL])
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>=ARRAY[0.1,
+                     0.2,
+                     NULL];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>=ARRAY[0.1,
+                     0.2,
+                     NULL]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=ARRAY[0.1,
+                        0.2,
+                        NULL])
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=ARRAY[0.1,
+                        0.2,
+                        NULL])
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float>=ARRAY[0.1,
+                     0.2,
+                     NULL];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B17_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float>=ARRAY[0.1,
+                     0.2,
+                     NULL]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float>=ARRAY[0.1,
+                     0.2,
+                     0.3];
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float>=ARRAY[0.1,
+                     0.2,
+                     0.3]
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=ARRAY[0.1,
+                        0.2,
+                        0.3]);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=ARRAY[0.1,
+                        0.2,
+                        0.3])
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>=ARRAY[0.1,
+                     0.2,
+                     0.3];
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>=ARRAY[0.1,
+                     0.2,
+                     0.3]
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=ARRAY[0.1,
+                        0.2,
+                        0.3])
+SELECT a_float
+FROM t1;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=ARRAY[0.1,
+                        0.2,
+                        0.3])
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float>=ARRAY[0.1,
+                     0.2,
+                     0.3];
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B18_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float>=ARRAY[0.1,
+                     0.2,
+                     0.3]
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float>=json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float>=json_value(a_nested, '$[2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=json_value(a_nested, '$[2]' RETURNING decimal array));
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=json_value(a_nested, '$[2]' RETURNING decimal array))
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>=json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>=json_value(a_nested, '$[2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=json_value(a_nested, '$[2]' RETURNING decimal array))
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=json_value(a_nested, '$[2]' RETURNING decimal array))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float>=json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B19_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float>=json_value(a_nested, '$[2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array));
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array))
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array))
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B20_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float<ARRAY[0.1,
+                    0.2];
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float<ARRAY[0.1,
+                    0.2]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<ARRAY[0.1,
+                       0.2]);
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<ARRAY[0.1,
+                       0.2])
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<ARRAY[0.1,
+                    0.2];
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<ARRAY[0.1,
+                    0.2]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<ARRAY[0.1,
+                       0.2])
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<ARRAY[0.1,
+                       0.2])
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float<ARRAY[0.1,
+                    0.2];
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B21_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float<ARRAY[0.1,
+                    0.2]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float<ARRAY[0.1,
+                    0.2,
+                    NULL];
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float<ARRAY[0.1,
+                    0.2,
+                    NULL]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<ARRAY[0.1,
+                       0.2,
+                       NULL]);
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<ARRAY[0.1,
+                       0.2,
+                       NULL])
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<ARRAY[0.1,
+                    0.2,
+                    NULL];
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<ARRAY[0.1,
+                    0.2,
+                    NULL]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<ARRAY[0.1,
+                       0.2,
+                       NULL])
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<ARRAY[0.1,
+                       0.2,
+                       NULL])
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float<ARRAY[0.1,
+                    0.2,
+                    NULL];
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B22_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float<ARRAY[0.1,
+                    0.2,
+                    NULL]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float<ARRAY[0.1,
+                    0.2,
+                    0.3];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float<ARRAY[0.1,
+                    0.2,
+                    0.3]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<ARRAY[0.1,
+                       0.2,
+                       0.3]);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<ARRAY[0.1,
+                       0.2,
+                       0.3])
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<ARRAY[0.1,
+                    0.2,
+                    0.3];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<ARRAY[0.1,
+                    0.2,
+                    0.3]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<ARRAY[0.1,
+                       0.2,
+                       0.3])
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<ARRAY[0.1,
+                       0.2,
+                       0.3])
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float<ARRAY[0.1,
+                    0.2,
+                    0.3];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B23_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float<ARRAY[0.1,
+                    0.2,
+                    0.3]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float<json_value(a_nested, '$[2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float<json_value(a_nested, '$[2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<json_value(a_nested, '$[2]' RETURNING decimal array));
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<json_value(a_nested, '$[2]' RETURNING decimal array))
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<json_value(a_nested, '$[2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<json_value(a_nested, '$[2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<json_value(a_nested, '$[2]' RETURNING decimal array))
+SELECT a_float
+FROM t1;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<json_value(a_nested, '$[2]' RETURNING decimal array))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float<json_value(a_nested, '$[2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B24_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float<json_value(a_nested, '$[2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float<json_value(a_nested, '$[7][2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float<json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<json_value(a_nested, '$[7][2]' RETURNING decimal array));
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<json_value(a_nested, '$[7][2]' RETURNING decimal array))
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<json_value(a_nested, '$[7][2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<json_value(a_nested, '$[7][2]' RETURNING decimal array))
+SELECT a_float
+FROM t1;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<json_value(a_nested, '$[7][2]' RETURNING decimal array))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float<json_value(a_nested, '$[7][2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B25_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float<json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float<=ARRAY[0.1,
+                     0.2];
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float<=ARRAY[0.1,
+                     0.2]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=ARRAY[0.1,
+                        0.2]);
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=ARRAY[0.1,
+                        0.2])
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<=ARRAY[0.1,
+                     0.2];
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<=ARRAY[0.1,
+                     0.2]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=ARRAY[0.1,
+                        0.2])
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=ARRAY[0.1,
+                        0.2])
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float<=ARRAY[0.1,
+                     0.2];
++------------------+
+| a_float          |
++------------------+
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B26_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float<=ARRAY[0.1,
+                     0.2]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float<=ARRAY[0.1,
+                     0.2,
+                     NULL];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float<=ARRAY[0.1,
+                     0.2,
+                     NULL]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=ARRAY[0.1,
+                        0.2,
+                        NULL]);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=ARRAY[0.1,
+                        0.2,
+                        NULL])
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<=ARRAY[0.1,
+                     0.2,
+                     NULL];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<=ARRAY[0.1,
+                     0.2,
+                     NULL]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=ARRAY[0.1,
+                        0.2,
+                        NULL])
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=ARRAY[0.1,
+                        0.2,
+                        NULL])
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float<=ARRAY[0.1,
+                     0.2,
+                     NULL];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B27_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float<=ARRAY[0.1,
+                     0.2,
+                     NULL]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float<=ARRAY[0.1,
+                     0.2,
+                     0.3];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float<=ARRAY[0.1,
+                     0.2,
+                     0.3]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=ARRAY[0.1,
+                        0.2,
+                        0.3]);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=ARRAY[0.1,
+                        0.2,
+                        0.3])
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<=ARRAY[0.1,
+                     0.2,
+                     0.3];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<=ARRAY[0.1,
+                     0.2,
+                     0.3]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=ARRAY[0.1,
+                        0.2,
+                        0.3])
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=ARRAY[0.1,
+                        0.2,
+                        0.3])
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float<=ARRAY[0.1,
+                     0.2,
+                     0.3];
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B28_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float<=ARRAY[0.1,
+                     0.2,
+                     0.3]
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array));
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array))
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array))
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B29_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float<=json_value(a_nested, '$[7][2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float<=json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=json_value(a_nested, '$[7][2]' RETURNING decimal array));
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=json_value(a_nested, '$[7][2]' RETURNING decimal array))
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<=json_value(a_nested, '$[7][2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<=json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=json_value(a_nested, '$[7][2]' RETURNING decimal array))
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=json_value(a_nested, '$[7][2]' RETURNING decimal array))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float<=json_value(a_nested, '$[7][2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B30_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float<=json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array)
+  OR a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array)
+  AND NOT (a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+           AND a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array));
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array)
+  OR a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array)
+  AND NOT (a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+           AND a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array))
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array)
+     OR a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array)
+     AND NOT (a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+              AND a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array)));
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array)
+     OR a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array)
+     AND NOT (a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+              AND a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array)))
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array)
+  OR a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array)
+  AND NOT (a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+           AND a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array));
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array)
+  OR a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array)
+  AND NOT (a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+           AND a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array))
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array)
+     OR a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array)
+     AND NOT (a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+              AND a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array)))
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array)
+     OR a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array)
+     AND NOT (a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+              AND a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array)))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array)
+  OR a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array)
+  AND NOT (a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+           AND a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array));
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B31_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float<=json_value(a_nested, '$[2]' RETURNING decimal array)
+  OR a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array)
+  AND NOT (a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+           AND a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array))
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE NOT (a_float<=json_value(a_nested, '$[2]' RETURNING decimal array))
+  OR NOT (a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array))
+  OR a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+  OR a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE NOT (a_float<=json_value(a_nested, '$[2]' RETURNING decimal array))
+  OR NOT (a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array))
+  OR a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+  OR a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_float<=json_value(a_nested, '$[2]' RETURNING decimal array))
+     OR NOT (a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array))
+     OR a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+     OR a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array));
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_float<=json_value(a_nested, '$[2]' RETURNING decimal array))
+     OR NOT (a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array))
+     OR a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+     OR a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array))
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE NOT (a_float<=json_value(a_nested, '$[2]' RETURNING decimal array))
+  OR NOT (a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array))
+  OR a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+  OR a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE NOT (a_float<=json_value(a_nested, '$[2]' RETURNING decimal array))
+  OR NOT (a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array))
+  OR a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+  OR a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_float<=json_value(a_nested, '$[2]' RETURNING decimal array))
+     OR NOT (a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array))
+     OR a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+     OR a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array))
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_float<=json_value(a_nested, '$[2]' RETURNING decimal array))
+     OR NOT (a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array))
+     OR a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+     OR a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE NOT (a_float<=json_value(a_nested, '$[2]' RETURNING decimal array))
+  OR NOT (a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array))
+  OR a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+  OR a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B32_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE NOT (a_float<=json_value(a_nested, '$[2]' RETURNING decimal array))
+  OR NOT (a_float>=json_value(a_nested, '$[7][2]' RETURNING decimal array))
+  OR a_float=json_value(a_nested, '$[2]' RETURNING decimal array)
+  OR a_float<>json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float IS NULL;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float IS NULL
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float IS NULL);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float IS NULL)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float IS NULL;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float IS NULL
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float IS NULL)
+SELECT a_float
+FROM t1;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float IS NULL)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float IS NULL;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B33_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float IS NULL
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float IS NOT NULL;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float IS NOT NULL
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float IS NOT NULL);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float IS NOT NULL)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float IS NOT NULL;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float IS NOT NULL
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float IS NOT NULL)
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float IS NOT NULL)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float IS NOT NULL;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B34_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float IS NOT NULL
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS TRUE;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS TRUE
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS TRUE);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS TRUE)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS TRUE;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS TRUE
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS TRUE)
+SELECT a_float
+FROM t1;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS TRUE)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS TRUE;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B35_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS TRUE
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT TRUE;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT TRUE
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT TRUE);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT TRUE)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT TRUE;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT TRUE
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT TRUE)
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT TRUE)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT TRUE;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B36_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT TRUE
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS FALSE;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS FALSE
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS FALSE);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS FALSE)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS FALSE;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS FALSE
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS FALSE)
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS FALSE)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS FALSE;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B37_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS FALSE
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT FALSE;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT FALSE
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT FALSE);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT FALSE)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT FALSE;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT FALSE
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT FALSE)
+SELECT a_float
+FROM t1;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT FALSE)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT FALSE;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B38_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE (a_float<json_value(a_nested, '$[2]' RETURNING decimal array)) IS NOT FALSE
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array));
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array))
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array))
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B39_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float NOT BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float NOT BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float NOT BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array));
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float NOT BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array))
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float NOT BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float NOT BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float NOT BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array))
+SELECT a_float
+FROM t1;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float NOT BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float NOT BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array);
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B40_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float NOT BETWEEN json_value(a_nested, '$[2]' RETURNING decimal array) AND json_value(a_nested, '$[7][2]' RETURNING decimal array)
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE array_to_string(a_float, ',') like '%';
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE array_to_string(a_float, ',') like '%'
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_float, ',') like '%');
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_float, ',') like '%')
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(a_float, ',') like '%';
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(a_float, ',') like '%'
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_float, ',') like '%')
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_float, ',') like '%')
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE array_to_string(a_float, ',') like '%';
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B41_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE array_to_string(a_float, ',') like '%'
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE array_to_string(json_value(a_nested, '$[2]' RETURNING decimal array), ',') not like '%';
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE array_to_string(json_value(a_nested, '$[2]' RETURNING decimal array), ',') not like '%'
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[2]' RETURNING decimal array), ',') not like '%');
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[2]' RETURNING decimal array), ',') not like '%')
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(json_value(a_nested, '$[2]' RETURNING decimal array), ',') not like '%';
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(json_value(a_nested, '$[2]' RETURNING decimal array), ',') not like '%'
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[2]' RETURNING decimal array), ',') not like '%')
+SELECT a_float
+FROM t1;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[2]' RETURNING decimal array), ',') not like '%')
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE array_to_string(json_value(a_nested, '$[2]' RETURNING decimal array), ',') not like '%';
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B42_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE array_to_string(json_value(a_nested, '$[2]' RETURNING decimal array), ',') not like '%'
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                  json_value(a_nested, '$[7][2]' RETURNING decimal array));
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                  json_value(a_nested, '$[7][2]' RETURNING decimal array))
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                     json_value(a_nested, '$[7][2]' RETURNING decimal array)));
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                     json_value(a_nested, '$[7][2]' RETURNING decimal array)))
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                  json_value(a_nested, '$[7][2]' RETURNING decimal array));
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                  json_value(a_nested, '$[7][2]' RETURNING decimal array))
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                     json_value(a_nested, '$[7][2]' RETURNING decimal array)))
+SELECT a_float
+FROM t1;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                     json_value(a_nested, '$[7][2]' RETURNING decimal array)))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                  json_value(a_nested, '$[7][2]' RETURNING decimal array));
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B43_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                  json_value(a_nested, '$[7][2]' RETURNING decimal array))
+GROUP BY a_float;
++------------------+-----+
+| a_float          | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float NOT IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                      json_value(a_nested, '$[7][2]' RETURNING decimal array));
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float NOT IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                      json_value(a_nested, '$[7][2]' RETURNING decimal array))
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float NOT IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                         json_value(a_nested, '$[7][2]' RETURNING decimal array)));
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float NOT IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                         json_value(a_nested, '$[7][2]' RETURNING decimal array)))
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float NOT IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                      json_value(a_nested, '$[7][2]' RETURNING decimal array));
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float NOT IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                      json_value(a_nested, '$[7][2]' RETURNING decimal array))
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float NOT IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                         json_value(a_nested, '$[7][2]' RETURNING decimal array)))
+SELECT a_float
+FROM t1;
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float NOT IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                         json_value(a_nested, '$[7][2]' RETURNING decimal array)))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float NOT IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                      json_value(a_nested, '$[7][2]' RETURNING decimal array));
++---------+
+| a_float |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B44_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float NOT IN (json_value(a_nested, '$[2]' RETURNING decimal array),
+                      json_value(a_nested, '$[7][2]' RETURNING decimal array))
+GROUP BY a_float;
++---------+-----+
+| a_float | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float IN
+    (SELECT a_float
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float IN
+    (SELECT a_float
+     FROM test_array)
+GROUP BY a_float;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float IN
+       (SELECT a_float
+        FROM test_array));
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float IN
+       (SELECT a_float
+        FROM test_array))
+GROUP BY a_float;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float IN
+    (SELECT a_float
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float IN
+    (SELECT a_float
+     FROM test_array)
+GROUP BY a_float;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float IN
+       (SELECT a_float
+        FROM test_array))
+SELECT a_float
+FROM t1;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float IN
+       (SELECT a_float
+        FROM test_array))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float IN
+    (SELECT a_float
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B45_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float IN
+    (SELECT a_float
+     FROM test_array)
+GROUP BY a_float;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM test_array
+WHERE a_float NOT IN
+    (SELECT a_float
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM test_array
+WHERE a_float NOT IN
+    (SELECT a_float
+     FROM test_array)
+GROUP BY a_float;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float NOT IN
+       (SELECT a_float
+        FROM test_array));
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_float NOT IN
+       (SELECT a_float
+        FROM test_array))
+GROUP BY a_float;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float NOT IN
+    (SELECT a_float
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_float NOT IN
+    (SELECT a_float
+     FROM test_array)
+GROUP BY a_float;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float NOT IN
+       (SELECT a_float
+        FROM test_array))
+SELECT a_float
+FROM t1;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_float NOT IN
+       (SELECT a_float
+        FROM test_array))
+SELECT a_float,
+       count(*) cnt
+FROM t1
+GROUP BY a_float;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float
+FROM t1
+WHERE a_float NOT IN
+    (SELECT a_float
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A3_B46_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_float,
+       count(*) cnt
+FROM t1
+WHERE a_float NOT IN
+    (SELECT a_float
+     FROM test_array)
+GROUP BY a_float;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str=ARRAY['S1',
+                  'S2'];
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str=ARRAY['S1',
+                  'S2']
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str=ARRAY['S1',
+                     'S2']);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str=ARRAY['S1',
+                     'S2'])
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str=ARRAY['S1',
+                  'S2'];
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str=ARRAY['S1',
+                  'S2']
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str=ARRAY['S1',
+                     'S2'])
+SELECT a_str
+FROM t1;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str=ARRAY['S1',
+                     'S2'])
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str=ARRAY['S1',
+                  'S2'];
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B1_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str=ARRAY['S1',
+                  'S2']
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str=ARRAY['S1',
+                  'S2',
+                  NULL];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str=ARRAY['S1',
+                  'S2',
+                  NULL]
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str=ARRAY['S1',
+                     'S2',
+                     NULL]);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str=ARRAY['S1',
+                     'S2',
+                     NULL])
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str=ARRAY['S1',
+                  'S2',
+                  NULL];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str=ARRAY['S1',
+                  'S2',
+                  NULL]
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str=ARRAY['S1',
+                     'S2',
+                     NULL])
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str=ARRAY['S1',
+                     'S2',
+                     NULL])
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str=ARRAY['S1',
+                  'S2',
+                  NULL];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B2_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str=ARRAY['S1',
+                  'S2',
+                  NULL]
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str=ARRAY['S1',
+                  'S2',
+                  'S3'];
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str=ARRAY['S1',
+                  'S2',
+                  'S3']
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str=ARRAY['S1',
+                     'S2',
+                     'S3']);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str=ARRAY['S1',
+                     'S2',
+                     'S3'])
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str=ARRAY['S1',
+                  'S2',
+                  'S3'];
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str=ARRAY['S1',
+                  'S2',
+                  'S3']
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str=ARRAY['S1',
+                     'S2',
+                     'S3'])
+SELECT a_str
+FROM t1;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str=ARRAY['S1',
+                     'S2',
+                     'S3'])
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str=ARRAY['S1',
+                  'S2',
+                  'S3'];
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B3_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str=ARRAY['S1',
+                  'S2',
+                  'S3']
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str=json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str=json_value(a_nested, '$[3]' RETURNING varchar array));
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str=json_value(a_nested, '$[3]' RETURNING varchar array))
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str=json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str=json_value(a_nested, '$[3]' RETURNING varchar array))
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str=json_value(a_nested, '$[3]' RETURNING varchar array))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str=json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B4_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str=json_value(a_nested, '$[7][3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str=json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str=json_value(a_nested, '$[7][3]' RETURNING varchar array));
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str=json_value(a_nested, '$[7][3]' RETURNING varchar array))
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str=json_value(a_nested, '$[7][3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str=json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str=json_value(a_nested, '$[7][3]' RETURNING varchar array))
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str=json_value(a_nested, '$[7][3]' RETURNING varchar array))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str=json_value(a_nested, '$[7][3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B5_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str=json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2'];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>ARRAY['S1',
+                      'S2']);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>ARRAY['S1',
+                      'S2'])
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<>ARRAY['S1',
+                   'S2'];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<>ARRAY['S1',
+                   'S2']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>ARRAY['S1',
+                      'S2'])
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>ARRAY['S1',
+                      'S2'])
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str<>ARRAY['S1',
+                   'S2'];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B6_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str<>ARRAY['S1',
+                   'S2']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL];
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL]
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>ARRAY['S1',
+                      'S2',
+                      NULL]);
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>ARRAY['S1',
+                      'S2',
+                      NULL])
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL];
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL]
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>ARRAY['S1',
+                      'S2',
+                      NULL])
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>ARRAY['S1',
+                      'S2',
+                      NULL])
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL];
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B7_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   NULL]
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   'S3'];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   'S3']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>ARRAY['S1',
+                      'S2',
+                      'S3']);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>ARRAY['S1',
+                      'S2',
+                      'S3'])
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   'S3'];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   'S3']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>ARRAY['S1',
+                      'S2',
+                      'S3'])
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>ARRAY['S1',
+                      'S2',
+                      'S3'])
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   'S3'];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B8_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str<>ARRAY['S1',
+                   'S2',
+                   'S3']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str<>json_value(a_nested, '$[3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str<>json_value(a_nested, '$[3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>json_value(a_nested, '$[3]' RETURNING varchar array));
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>json_value(a_nested, '$[3]' RETURNING varchar array))
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<>json_value(a_nested, '$[3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<>json_value(a_nested, '$[3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>json_value(a_nested, '$[3]' RETURNING varchar array))
+SELECT a_str
+FROM t1;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>json_value(a_nested, '$[3]' RETURNING varchar array))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str<>json_value(a_nested, '$[3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B9_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str<>json_value(a_nested, '$[3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array));
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array))
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array))
+SELECT a_str
+FROM t1;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B10_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str>ARRAY['S1',
+                  'S2'];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str>ARRAY['S1',
+                  'S2']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>ARRAY['S1',
+                     'S2']);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>ARRAY['S1',
+                     'S2'])
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>ARRAY['S1',
+                  'S2'];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>ARRAY['S1',
+                  'S2']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>ARRAY['S1',
+                     'S2'])
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>ARRAY['S1',
+                     'S2'])
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str>ARRAY['S1',
+                  'S2'];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B11_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str>ARRAY['S1',
+                  'S2']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str>ARRAY['S1',
+                  'S2',
+                  NULL];
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str>ARRAY['S1',
+                  'S2',
+                  NULL]
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>ARRAY['S1',
+                     'S2',
+                     NULL]);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>ARRAY['S1',
+                     'S2',
+                     NULL])
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>ARRAY['S1',
+                  'S2',
+                  NULL];
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>ARRAY['S1',
+                  'S2',
+                  NULL]
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>ARRAY['S1',
+                     'S2',
+                     NULL])
+SELECT a_str
+FROM t1;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>ARRAY['S1',
+                     'S2',
+                     NULL])
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str>ARRAY['S1',
+                  'S2',
+                  NULL];
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B12_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str>ARRAY['S1',
+                  'S2',
+                  NULL]
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str>ARRAY['S1',
+                  'S2',
+                  'S3'];
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str>ARRAY['S1',
+                  'S2',
+                  'S3']
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>ARRAY['S1',
+                     'S2',
+                     'S3']);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>ARRAY['S1',
+                     'S2',
+                     'S3'])
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>ARRAY['S1',
+                  'S2',
+                  'S3'];
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>ARRAY['S1',
+                  'S2',
+                  'S3']
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>ARRAY['S1',
+                     'S2',
+                     'S3'])
+SELECT a_str
+FROM t1;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>ARRAY['S1',
+                     'S2',
+                     'S3'])
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str>ARRAY['S1',
+                  'S2',
+                  'S3'];
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B13_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str>ARRAY['S1',
+                  'S2',
+                  'S3']
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str>json_value(a_nested, '$[3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str>json_value(a_nested, '$[3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>json_value(a_nested, '$[3]' RETURNING varchar array));
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>json_value(a_nested, '$[3]' RETURNING varchar array))
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>json_value(a_nested, '$[3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>json_value(a_nested, '$[3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>json_value(a_nested, '$[3]' RETURNING varchar array))
+SELECT a_str
+FROM t1;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>json_value(a_nested, '$[3]' RETURNING varchar array))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str>json_value(a_nested, '$[3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B14_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str>json_value(a_nested, '$[3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str>json_value(a_nested, '$[7][3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str>json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>json_value(a_nested, '$[7][3]' RETURNING varchar array));
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>json_value(a_nested, '$[7][3]' RETURNING varchar array))
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>json_value(a_nested, '$[7][3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>json_value(a_nested, '$[7][3]' RETURNING varchar array))
+SELECT a_str
+FROM t1;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>json_value(a_nested, '$[7][3]' RETURNING varchar array))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str>json_value(a_nested, '$[7][3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B15_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str>json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str>=ARRAY['S1',
+                   'S2'];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str>=ARRAY['S1',
+                   'S2']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=ARRAY['S1',
+                      'S2']);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=ARRAY['S1',
+                      'S2'])
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>=ARRAY['S1',
+                   'S2'];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>=ARRAY['S1',
+                   'S2']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=ARRAY['S1',
+                      'S2'])
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=ARRAY['S1',
+                      'S2'])
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str>=ARRAY['S1',
+                   'S2'];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B16_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str>=ARRAY['S1',
+                   'S2']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str>=ARRAY['S1',
+                   'S2',
+                   NULL];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str>=ARRAY['S1',
+                   'S2',
+                   NULL]
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=ARRAY['S1',
+                      'S2',
+                      NULL]);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=ARRAY['S1',
+                      'S2',
+                      NULL])
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>=ARRAY['S1',
+                   'S2',
+                   NULL];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>=ARRAY['S1',
+                   'S2',
+                   NULL]
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=ARRAY['S1',
+                      'S2',
+                      NULL])
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=ARRAY['S1',
+                      'S2',
+                      NULL])
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str>=ARRAY['S1',
+                   'S2',
+                   NULL];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B17_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str>=ARRAY['S1',
+                   'S2',
+                   NULL]
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str>=ARRAY['S1',
+                   'S2',
+                   'S3'];
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str>=ARRAY['S1',
+                   'S2',
+                   'S3']
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=ARRAY['S1',
+                      'S2',
+                      'S3']);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=ARRAY['S1',
+                      'S2',
+                      'S3'])
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>=ARRAY['S1',
+                   'S2',
+                   'S3'];
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>=ARRAY['S1',
+                   'S2',
+                   'S3']
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=ARRAY['S1',
+                      'S2',
+                      'S3'])
+SELECT a_str
+FROM t1;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=ARRAY['S1',
+                      'S2',
+                      'S3'])
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str>=ARRAY['S1',
+                   'S2',
+                   'S3'];
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B18_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str>=ARRAY['S1',
+                   'S2',
+                   'S3']
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str>=json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str>=json_value(a_nested, '$[3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=json_value(a_nested, '$[3]' RETURNING varchar array));
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=json_value(a_nested, '$[3]' RETURNING varchar array))
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>=json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>=json_value(a_nested, '$[3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=json_value(a_nested, '$[3]' RETURNING varchar array))
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=json_value(a_nested, '$[3]' RETURNING varchar array))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str>=json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B19_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str>=json_value(a_nested, '$[3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array));
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array))
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array))
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B20_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str<ARRAY['S1',
+                  'S2'];
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str<ARRAY['S1',
+                  'S2']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<ARRAY['S1',
+                     'S2']);
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<ARRAY['S1',
+                     'S2'])
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<ARRAY['S1',
+                  'S2'];
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<ARRAY['S1',
+                  'S2']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<ARRAY['S1',
+                     'S2'])
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<ARRAY['S1',
+                     'S2'])
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str<ARRAY['S1',
+                  'S2'];
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B21_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str<ARRAY['S1',
+                  'S2']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str<ARRAY['S1',
+                  'S2',
+                  NULL];
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str<ARRAY['S1',
+                  'S2',
+                  NULL]
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<ARRAY['S1',
+                     'S2',
+                     NULL]);
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<ARRAY['S1',
+                     'S2',
+                     NULL])
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<ARRAY['S1',
+                  'S2',
+                  NULL];
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<ARRAY['S1',
+                  'S2',
+                  NULL]
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<ARRAY['S1',
+                     'S2',
+                     NULL])
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<ARRAY['S1',
+                     'S2',
+                     NULL])
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str<ARRAY['S1',
+                  'S2',
+                  NULL];
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B22_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str<ARRAY['S1',
+                  'S2',
+                  NULL]
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str<ARRAY['S1',
+                  'S2',
+                  'S3'];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str<ARRAY['S1',
+                  'S2',
+                  'S3']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<ARRAY['S1',
+                     'S2',
+                     'S3']);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<ARRAY['S1',
+                     'S2',
+                     'S3'])
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<ARRAY['S1',
+                  'S2',
+                  'S3'];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<ARRAY['S1',
+                  'S2',
+                  'S3']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<ARRAY['S1',
+                     'S2',
+                     'S3'])
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<ARRAY['S1',
+                     'S2',
+                     'S3'])
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str<ARRAY['S1',
+                  'S2',
+                  'S3'];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B23_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str<ARRAY['S1',
+                  'S2',
+                  'S3']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str<json_value(a_nested, '$[3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str<json_value(a_nested, '$[3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<json_value(a_nested, '$[3]' RETURNING varchar array));
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<json_value(a_nested, '$[3]' RETURNING varchar array))
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<json_value(a_nested, '$[3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<json_value(a_nested, '$[3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<json_value(a_nested, '$[3]' RETURNING varchar array))
+SELECT a_str
+FROM t1;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<json_value(a_nested, '$[3]' RETURNING varchar array))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str<json_value(a_nested, '$[3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B24_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str<json_value(a_nested, '$[3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str<json_value(a_nested, '$[7][3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str<json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<json_value(a_nested, '$[7][3]' RETURNING varchar array));
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<json_value(a_nested, '$[7][3]' RETURNING varchar array))
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<json_value(a_nested, '$[7][3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<json_value(a_nested, '$[7][3]' RETURNING varchar array))
+SELECT a_str
+FROM t1;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<json_value(a_nested, '$[7][3]' RETURNING varchar array))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str<json_value(a_nested, '$[7][3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B25_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str<json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str<=ARRAY['S1',
+                   'S2'];
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str<=ARRAY['S1',
+                   'S2']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=ARRAY['S1',
+                      'S2']);
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=ARRAY['S1',
+                      'S2'])
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<=ARRAY['S1',
+                   'S2'];
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<=ARRAY['S1',
+                   'S2']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=ARRAY['S1',
+                      'S2'])
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=ARRAY['S1',
+                      'S2'])
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str<=ARRAY['S1',
+                   'S2'];
++----------------+
+| a_str          |
++----------------+
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B26_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str<=ARRAY['S1',
+                   'S2']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str<=ARRAY['S1',
+                   'S2',
+                   NULL];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str<=ARRAY['S1',
+                   'S2',
+                   NULL]
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=ARRAY['S1',
+                      'S2',
+                      NULL]);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=ARRAY['S1',
+                      'S2',
+                      NULL])
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<=ARRAY['S1',
+                   'S2',
+                   NULL];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<=ARRAY['S1',
+                   'S2',
+                   NULL]
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=ARRAY['S1',
+                      'S2',
+                      NULL])
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=ARRAY['S1',
+                      'S2',
+                      NULL])
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str<=ARRAY['S1',
+                   'S2',
+                   NULL];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B27_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str<=ARRAY['S1',
+                   'S2',
+                   NULL]
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str<=ARRAY['S1',
+                   'S2',
+                   'S3'];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str<=ARRAY['S1',
+                   'S2',
+                   'S3']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=ARRAY['S1',
+                      'S2',
+                      'S3']);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=ARRAY['S1',
+                      'S2',
+                      'S3'])
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<=ARRAY['S1',
+                   'S2',
+                   'S3'];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<=ARRAY['S1',
+                   'S2',
+                   'S3']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=ARRAY['S1',
+                      'S2',
+                      'S3'])
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=ARRAY['S1',
+                      'S2',
+                      'S3'])
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str<=ARRAY['S1',
+                   'S2',
+                   'S3'];
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B28_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str<=ARRAY['S1',
+                   'S2',
+                   'S3']
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array));
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array))
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array))
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B29_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str<=json_value(a_nested, '$[7][3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str<=json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=json_value(a_nested, '$[7][3]' RETURNING varchar array));
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=json_value(a_nested, '$[7][3]' RETURNING varchar array))
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<=json_value(a_nested, '$[7][3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<=json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=json_value(a_nested, '$[7][3]' RETURNING varchar array))
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=json_value(a_nested, '$[7][3]' RETURNING varchar array))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str<=json_value(a_nested, '$[7][3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B30_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str<=json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array)
+  OR a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array)
+  AND NOT (a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+           AND a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array));
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array)
+  OR a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array)
+  AND NOT (a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+           AND a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array))
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array)
+     OR a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array)
+     AND NOT (a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+              AND a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array)));
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array)
+     OR a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array)
+     AND NOT (a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+              AND a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array)))
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array)
+  OR a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array)
+  AND NOT (a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+           AND a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array));
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array)
+  OR a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array)
+  AND NOT (a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+           AND a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array))
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array)
+     OR a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array)
+     AND NOT (a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+              AND a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array)))
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array)
+     OR a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array)
+     AND NOT (a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+              AND a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array)))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array)
+  OR a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array)
+  AND NOT (a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+           AND a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array));
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B31_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str<=json_value(a_nested, '$[3]' RETURNING varchar array)
+  OR a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array)
+  AND NOT (a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+           AND a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array))
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE NOT (a_str<=json_value(a_nested, '$[3]' RETURNING varchar array))
+  OR NOT (a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array))
+  OR a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+  OR a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE NOT (a_str<=json_value(a_nested, '$[3]' RETURNING varchar array))
+  OR NOT (a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array))
+  OR a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+  OR a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_str<=json_value(a_nested, '$[3]' RETURNING varchar array))
+     OR NOT (a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array))
+     OR a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+     OR a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array));
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_str<=json_value(a_nested, '$[3]' RETURNING varchar array))
+     OR NOT (a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array))
+     OR a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+     OR a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array))
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE NOT (a_str<=json_value(a_nested, '$[3]' RETURNING varchar array))
+  OR NOT (a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array))
+  OR a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+  OR a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE NOT (a_str<=json_value(a_nested, '$[3]' RETURNING varchar array))
+  OR NOT (a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array))
+  OR a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+  OR a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_str<=json_value(a_nested, '$[3]' RETURNING varchar array))
+     OR NOT (a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array))
+     OR a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+     OR a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array))
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_str<=json_value(a_nested, '$[3]' RETURNING varchar array))
+     OR NOT (a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array))
+     OR a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+     OR a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE NOT (a_str<=json_value(a_nested, '$[3]' RETURNING varchar array))
+  OR NOT (a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array))
+  OR a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+  OR a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B32_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE NOT (a_str<=json_value(a_nested, '$[3]' RETURNING varchar array))
+  OR NOT (a_str>=json_value(a_nested, '$[7][3]' RETURNING varchar array))
+  OR a_str=json_value(a_nested, '$[3]' RETURNING varchar array)
+  OR a_str<>json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str IS NULL;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str IS NULL
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str IS NULL);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str IS NULL)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str IS NULL;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str IS NULL
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str IS NULL)
+SELECT a_str
+FROM t1;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str IS NULL)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str IS NULL;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B33_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str IS NULL
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str IS NOT NULL;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str IS NOT NULL
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str IS NOT NULL);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str IS NOT NULL)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str IS NOT NULL;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str IS NOT NULL
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str IS NOT NULL)
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str IS NOT NULL)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str IS NOT NULL;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B34_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str IS NOT NULL
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS TRUE;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS TRUE
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS TRUE);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS TRUE)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS TRUE;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS TRUE
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS TRUE)
+SELECT a_str
+FROM t1;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS TRUE)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS TRUE;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B35_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS TRUE
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT TRUE;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT TRUE
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT TRUE);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT TRUE)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT TRUE;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT TRUE
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT TRUE)
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT TRUE)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT TRUE;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B36_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT TRUE
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS FALSE;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS FALSE
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS FALSE);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS FALSE)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS FALSE;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS FALSE
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS FALSE)
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS FALSE)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS FALSE;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B37_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS FALSE
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT FALSE;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT FALSE
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT FALSE);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT FALSE)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT FALSE;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT FALSE
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT FALSE)
+SELECT a_str
+FROM t1;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT FALSE)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT FALSE;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B38_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE (a_str<json_value(a_nested, '$[3]' RETURNING varchar array)) IS NOT FALSE
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array));
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array))
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array))
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B39_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str NOT BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str NOT BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str NOT BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array));
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str NOT BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array))
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str NOT BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str NOT BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str NOT BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array))
+SELECT a_str
+FROM t1;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str NOT BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str NOT BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array);
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B40_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str NOT BETWEEN json_value(a_nested, '$[3]' RETURNING varchar array) AND json_value(a_nested, '$[7][3]' RETURNING varchar array)
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE array_to_string(a_str, ',') like '%';
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE array_to_string(a_str, ',') like '%'
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_str, ',') like '%');
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_str, ',') like '%')
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(a_str, ',') like '%';
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(a_str, ',') like '%'
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_str, ',') like '%')
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_str, ',') like '%')
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE array_to_string(a_str, ',') like '%';
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B41_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE array_to_string(a_str, ',') like '%'
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE array_to_string(json_value(a_nested, '$[3]' RETURNING varchar array), ',') not like '%';
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE array_to_string(json_value(a_nested, '$[3]' RETURNING varchar array), ',') not like '%'
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[3]' RETURNING varchar array), ',') not like '%');
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[3]' RETURNING varchar array), ',') not like '%')
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(json_value(a_nested, '$[3]' RETURNING varchar array), ',') not like '%';
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(json_value(a_nested, '$[3]' RETURNING varchar array), ',') not like '%'
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[3]' RETURNING varchar array), ',') not like '%')
+SELECT a_str
+FROM t1;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[3]' RETURNING varchar array), ',') not like '%')
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE array_to_string(json_value(a_nested, '$[3]' RETURNING varchar array), ',') not like '%';
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B42_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE array_to_string(json_value(a_nested, '$[3]' RETURNING varchar array), ',') not like '%'
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                json_value(a_nested, '$[7][3]' RETURNING varchar array));
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                json_value(a_nested, '$[7][3]' RETURNING varchar array))
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                   json_value(a_nested, '$[7][3]' RETURNING varchar array)));
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                   json_value(a_nested, '$[7][3]' RETURNING varchar array)))
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                json_value(a_nested, '$[7][3]' RETURNING varchar array));
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                json_value(a_nested, '$[7][3]' RETURNING varchar array))
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                   json_value(a_nested, '$[7][3]' RETURNING varchar array)))
+SELECT a_str
+FROM t1;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                   json_value(a_nested, '$[7][3]' RETURNING varchar array)))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                json_value(a_nested, '$[7][3]' RETURNING varchar array));
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B43_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                json_value(a_nested, '$[7][3]' RETURNING varchar array))
+GROUP BY a_str;
++----------------+-----+
+| a_str          | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str NOT IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                    json_value(a_nested, '$[7][3]' RETURNING varchar array));
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str NOT IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                    json_value(a_nested, '$[7][3]' RETURNING varchar array))
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str NOT IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                       json_value(a_nested, '$[7][3]' RETURNING varchar array)));
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str NOT IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                       json_value(a_nested, '$[7][3]' RETURNING varchar array)))
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str NOT IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                    json_value(a_nested, '$[7][3]' RETURNING varchar array));
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str NOT IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                    json_value(a_nested, '$[7][3]' RETURNING varchar array))
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str NOT IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                       json_value(a_nested, '$[7][3]' RETURNING varchar array)))
+SELECT a_str
+FROM t1;
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str NOT IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                       json_value(a_nested, '$[7][3]' RETURNING varchar array)))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str NOT IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                    json_value(a_nested, '$[7][3]' RETURNING varchar array));
++-------+
+| a_str |
++-------+
++-------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B44_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str NOT IN (json_value(a_nested, '$[3]' RETURNING varchar array),
+                    json_value(a_nested, '$[7][3]' RETURNING varchar array))
+GROUP BY a_str;
++-------+-----+
+| a_str | cnt |
++-------+-----+
++-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str IN
+    (SELECT a_str
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str IN
+    (SELECT a_str
+     FROM test_array)
+GROUP BY a_str;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str IN
+       (SELECT a_str
+        FROM test_array));
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str IN
+       (SELECT a_str
+        FROM test_array))
+GROUP BY a_str;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str IN
+    (SELECT a_str
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str IN
+    (SELECT a_str
+     FROM test_array)
+GROUP BY a_str;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str IN
+       (SELECT a_str
+        FROM test_array))
+SELECT a_str
+FROM t1;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str IN
+       (SELECT a_str
+        FROM test_array))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str IN
+    (SELECT a_str
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B45_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str IN
+    (SELECT a_str
+     FROM test_array)
+GROUP BY a_str;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM test_array
+WHERE a_str NOT IN
+    (SELECT a_str
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM test_array
+WHERE a_str NOT IN
+    (SELECT a_str
+     FROM test_array)
+GROUP BY a_str;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str NOT IN
+       (SELECT a_str
+        FROM test_array));
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_str NOT IN
+       (SELECT a_str
+        FROM test_array))
+GROUP BY a_str;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str NOT IN
+    (SELECT a_str
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_str NOT IN
+    (SELECT a_str
+     FROM test_array)
+GROUP BY a_str;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str NOT IN
+       (SELECT a_str
+        FROM test_array))
+SELECT a_str
+FROM t1;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_str NOT IN
+       (SELECT a_str
+        FROM test_array))
+SELECT a_str,
+       count(*) cnt
+FROM t1
+GROUP BY a_str;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str
+FROM t1
+WHERE a_str NOT IN
+    (SELECT a_str
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A4_B46_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_str,
+       count(*) cnt
+FROM t1
+WHERE a_str NOT IN
+    (SELECT a_str
+     FROM test_array)
+GROUP BY a_str;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed=ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1'];
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed=ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1']
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1']);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1'])
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed=ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1'];
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B1_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed=ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1']
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1'])
+SELECT a_mixed
+FROM t1;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B1_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1'])
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed=ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1'];
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B1_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed=ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1']
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed=ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed=ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL]
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL]);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL])
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed=ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B2_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed=ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL]
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL])
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B2_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL])
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed=ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B2_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed=ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL]
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed=ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL,
+                    'extra element'];
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B3_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed=ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL,
+                    'extra element']
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL,
+                       'extra element']);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B3_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL,
+                       'extra element'])
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B3_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed=ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL,
+                    'extra element'];
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B3_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed=ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL,
+                    'extra element']
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B3_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL,
+                       'extra element'])
+SELECT a_mixed
+FROM t1;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B3_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL,
+                       'extra element'])
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B3_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed=ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL,
+                    'extra element'];
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B3_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed=ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL,
+                    'extra element']
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B4_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array));
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B4_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array))
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B4_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B4_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B4_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array))
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B4_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B4_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B4_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed=json_value(a_nested, '$[7][6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B5_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed=json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=json_value(a_nested, '$[7][6]' RETURNING varchar array));
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B5_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=json_value(a_nested, '$[7][6]' RETURNING varchar array))
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B5_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed=json_value(a_nested, '$[7][6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B5_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed=json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B5_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=json_value(a_nested, '$[7][6]' RETURNING varchar array))
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B5_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed=json_value(a_nested, '$[7][6]' RETURNING varchar array))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B5_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed=json_value(a_nested, '$[7][6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B5_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed=json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B6_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1']);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B6_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1'])
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B6_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B6_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B6_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1'])
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B6_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1'])
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B6_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B6_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B7_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL]
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL]);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B7_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL])
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B7_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B7_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL]
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B7_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL])
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B7_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL])
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B7_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B7_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL]
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL,
+                     'extra element'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B8_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL,
+                     'extra element']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL,
+                        'extra element']);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B8_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL,
+                        'extra element'])
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B8_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL,
+                     'extra element'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B8_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL,
+                     'extra element']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL,
+                        'extra element'])
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B8_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL,
+                        'extra element'])
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL,
+                     'extra element'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B8_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed<>ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL,
+                     'extra element']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed<>json_value(a_nested, '$[6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B9_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed<>json_value(a_nested, '$[6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>json_value(a_nested, '$[6]' RETURNING varchar array));
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B9_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>json_value(a_nested, '$[6]' RETURNING varchar array))
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B9_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<>json_value(a_nested, '$[6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B9_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<>json_value(a_nested, '$[6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B9_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>json_value(a_nested, '$[6]' RETURNING varchar array))
+SELECT a_mixed
+FROM t1;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B9_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>json_value(a_nested, '$[6]' RETURNING varchar array))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B9_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed<>json_value(a_nested, '$[6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B9_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed<>json_value(a_nested, '$[6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B10_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array));
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B10_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array))
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B10_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B10_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B10_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array))
+SELECT a_mixed
+FROM t1;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B10_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B10_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B10_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed>ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B11_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed>ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1']);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B11_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1'])
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B11_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B11_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B11_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1'])
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B11_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1'])
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B11_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed>ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B11_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed>ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed>ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL];
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B12_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed>ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL]
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL]);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B12_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL])
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B12_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL];
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B12_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL]
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B12_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL])
+SELECT a_mixed
+FROM t1;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B12_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL])
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B12_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed>ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL];
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B12_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed>ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL]
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed>ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL,
+                    'extra element'];
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B13_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed>ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL,
+                    'extra element']
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B13_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL,
+                       'extra element']);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B13_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL,
+                       'extra element'])
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B13_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL,
+                    'extra element'];
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B13_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL,
+                    'extra element']
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B13_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL,
+                       'extra element'])
+SELECT a_mixed
+FROM t1;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B13_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL,
+                       'extra element'])
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B13_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed>ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL,
+                    'extra element'];
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B13_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed>ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL,
+                    'extra element']
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed>json_value(a_nested, '$[6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B14_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed>json_value(a_nested, '$[6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>json_value(a_nested, '$[6]' RETURNING varchar array));
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B14_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>json_value(a_nested, '$[6]' RETURNING varchar array))
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B14_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>json_value(a_nested, '$[6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B14_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>json_value(a_nested, '$[6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B14_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>json_value(a_nested, '$[6]' RETURNING varchar array))
+SELECT a_mixed
+FROM t1;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B14_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>json_value(a_nested, '$[6]' RETURNING varchar array))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B14_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed>json_value(a_nested, '$[6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B14_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed>json_value(a_nested, '$[6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B15_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed>json_value(a_nested, '$[7][6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B15_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed>json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B15_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>json_value(a_nested, '$[7][6]' RETURNING varchar array));
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B15_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>json_value(a_nested, '$[7][6]' RETURNING varchar array))
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B15_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>json_value(a_nested, '$[7][6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B15_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B15_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>json_value(a_nested, '$[7][6]' RETURNING varchar array))
+SELECT a_mixed
+FROM t1;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B15_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>json_value(a_nested, '$[7][6]' RETURNING varchar array))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B15_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed>json_value(a_nested, '$[7][6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B15_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed>json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B16_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed>=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B16_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed>=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B16_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1']);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B16_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1'])
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B16_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B16_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B16_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1'])
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B16_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1'])
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B16_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed>=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B16_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed>=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B17_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed>=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B17_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed>=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL]
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B17_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL]);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B17_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL])
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B17_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B17_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL]
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B17_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL])
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B17_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL])
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B17_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed>=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B17_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed>=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL]
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B18_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed>=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL,
+                     'extra element'];
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B18_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed>=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL,
+                     'extra element']
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B18_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL,
+                        'extra element']);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B18_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL,
+                        'extra element'])
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B18_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL,
+                     'extra element'];
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B18_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL,
+                     'extra element']
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B18_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL,
+                        'extra element'])
+SELECT a_mixed
+FROM t1;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B18_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL,
+                        'extra element'])
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B18_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed>=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL,
+                     'extra element'];
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B18_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed>=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL,
+                     'extra element']
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed>=json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B19_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed>=json_value(a_nested, '$[6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=json_value(a_nested, '$[6]' RETURNING varchar array));
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B19_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=json_value(a_nested, '$[6]' RETURNING varchar array))
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B19_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>=json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B19_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>=json_value(a_nested, '$[6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=json_value(a_nested, '$[6]' RETURNING varchar array))
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B19_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=json_value(a_nested, '$[6]' RETURNING varchar array))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed>=json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B19_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed>=json_value(a_nested, '$[6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B20_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array));
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B20_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array))
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B20_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B20_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array))
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B20_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B20_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B21_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed<ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B21_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed<ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B21_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1']);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B21_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1'])
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B21_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B21_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B21_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1'])
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B21_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1'])
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B21_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed<ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B21_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed<ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B22_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed<ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B22_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed<ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL]
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B22_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL]);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B22_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL])
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B22_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B22_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL]
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B22_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL])
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B22_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL])
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B22_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed<ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B22_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed<ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL]
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B23_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed<ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL,
+                    'extra element'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B23_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed<ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL,
+                    'extra element']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B23_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL,
+                       'extra element']);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B23_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL,
+                       'extra element'])
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B23_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL,
+                    'extra element'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B23_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL,
+                    'extra element']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B23_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL,
+                       'extra element'])
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B23_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<ARRAY['true',
+                       '1',
+                       '0.1',
+                       'S1',
+                       NULL,
+                       'extra element'])
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B23_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed<ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL,
+                    'extra element'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B23_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed<ARRAY['true',
+                    '1',
+                    '0.1',
+                    'S1',
+                    NULL,
+                    'extra element']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B24_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B24_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B24_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array));
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B24_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array))
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B24_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B24_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B24_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array))
+SELECT a_mixed
+FROM t1;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B24_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B24_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B24_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B25_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed<json_value(a_nested, '$[7][6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B25_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed<json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B25_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<json_value(a_nested, '$[7][6]' RETURNING varchar array));
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B25_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<json_value(a_nested, '$[7][6]' RETURNING varchar array))
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B25_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<json_value(a_nested, '$[7][6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B25_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B25_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<json_value(a_nested, '$[7][6]' RETURNING varchar array))
+SELECT a_mixed
+FROM t1;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B25_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<json_value(a_nested, '$[7][6]' RETURNING varchar array))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B25_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed<json_value(a_nested, '$[7][6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B25_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed<json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B26_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed<=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B26_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed<=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B26_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1']);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B26_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1'])
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B26_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B26_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B26_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1'])
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B26_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1'])
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B26_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed<=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
++--------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B26_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed<=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B27_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed<=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B27_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed<=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL]
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B27_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL]);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B27_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL])
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B27_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B27_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL]
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B27_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL])
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B27_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL])
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B27_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed<=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B27_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed<=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL]
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B28_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed<=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL,
+                     'extra element'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B28_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed<=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL,
+                     'extra element']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B28_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL,
+                        'extra element']);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B28_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL,
+                        'extra element'])
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B28_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL,
+                     'extra element'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B28_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL,
+                     'extra element']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B28_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL,
+                        'extra element'])
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B28_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=ARRAY['true',
+                        '1',
+                        '0.1',
+                        'S1',
+                        NULL,
+                        'extra element'])
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B28_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed<=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL,
+                     'extra element'];
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B28_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed<=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL,
+                     'extra element']
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B29_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B29_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B29_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array));
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B29_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array))
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B29_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B29_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B29_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array))
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B29_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B29_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B29_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B30_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed<=json_value(a_nested, '$[7][6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B30_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed<=json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B30_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=json_value(a_nested, '$[7][6]' RETURNING varchar array));
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B30_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=json_value(a_nested, '$[7][6]' RETURNING varchar array))
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B30_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<=json_value(a_nested, '$[7][6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B30_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<=json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B30_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=json_value(a_nested, '$[7][6]' RETURNING varchar array))
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B30_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=json_value(a_nested, '$[7][6]' RETURNING varchar array))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B30_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed<=json_value(a_nested, '$[7][6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B30_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed<=json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B31_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array)
+  OR a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array)
+  AND NOT (a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+           AND a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array));
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B31_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array)
+  OR a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array)
+  AND NOT (a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+           AND a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array))
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B31_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array)
+     OR a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array)
+     AND NOT (a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+              AND a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array)));
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B31_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array)
+     OR a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array)
+     AND NOT (a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+              AND a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array)))
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B31_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array)
+  OR a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array)
+  AND NOT (a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+           AND a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array));
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B31_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array)
+  OR a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array)
+  AND NOT (a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+           AND a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array))
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B31_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array)
+     OR a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array)
+     AND NOT (a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+              AND a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array)))
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B31_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array)
+     OR a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array)
+     AND NOT (a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+              AND a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array)))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B31_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array)
+  OR a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array)
+  AND NOT (a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+           AND a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array));
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B31_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array)
+  OR a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array)
+  AND NOT (a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+           AND a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array))
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B32_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE NOT (a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array))
+  OR NOT (a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array))
+  OR a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+  OR a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B32_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE NOT (a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array))
+  OR NOT (a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array))
+  OR a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+  OR a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B32_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array))
+     OR NOT (a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array))
+     OR a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+     OR a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array));
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B32_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array))
+     OR NOT (a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array))
+     OR a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+     OR a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array))
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B32_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE NOT (a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array))
+  OR NOT (a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array))
+  OR a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+  OR a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B32_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE NOT (a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array))
+  OR NOT (a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array))
+  OR a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+  OR a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B32_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array))
+     OR NOT (a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array))
+     OR a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+     OR a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array))
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B32_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array))
+     OR NOT (a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array))
+     OR a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+     OR a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B32_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE NOT (a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array))
+  OR NOT (a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array))
+  OR a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+  OR a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B32_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE NOT (a_mixed<=json_value(a_nested, '$[6]' RETURNING varchar array))
+  OR NOT (a_mixed>=json_value(a_nested, '$[7][6]' RETURNING varchar array))
+  OR a_mixed=json_value(a_nested, '$[6]' RETURNING varchar array)
+  OR a_mixed<>json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B33_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed IS NULL;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B33_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed IS NULL
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B33_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed IS NULL);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B33_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed IS NULL)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B33_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed IS NULL;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B33_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed IS NULL
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B33_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed IS NULL)
+SELECT a_mixed
+FROM t1;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B33_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed IS NULL)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B33_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed IS NULL;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B33_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed IS NULL
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B34_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed IS NOT NULL;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B34_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed IS NOT NULL
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B34_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed IS NOT NULL);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B34_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed IS NOT NULL)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B34_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed IS NOT NULL;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B34_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed IS NOT NULL
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B34_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed IS NOT NULL)
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B34_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed IS NOT NULL)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B34_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed IS NOT NULL;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B34_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed IS NOT NULL
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B35_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS TRUE;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B35_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS TRUE
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B35_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS TRUE);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B35_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS TRUE)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B35_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS TRUE;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B35_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS TRUE
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B35_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS TRUE)
+SELECT a_mixed
+FROM t1;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B35_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS TRUE)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B35_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS TRUE;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B35_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS TRUE
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B36_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT TRUE;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B36_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT TRUE
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B36_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT TRUE);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B36_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT TRUE)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B36_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT TRUE;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B36_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT TRUE
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B36_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT TRUE)
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B36_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT TRUE)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B36_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT TRUE;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B36_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT TRUE
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B37_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS FALSE;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B37_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS FALSE
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B37_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS FALSE);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B37_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS FALSE)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B37_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS FALSE;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B37_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS FALSE
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B37_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS FALSE)
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B37_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS FALSE)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B37_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS FALSE;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B37_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS FALSE
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B38_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT FALSE;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B38_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT FALSE
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B38_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT FALSE);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B38_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT FALSE)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B38_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT FALSE;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B38_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT FALSE
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B38_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT FALSE)
+SELECT a_mixed
+FROM t1;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B38_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT FALSE)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B38_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT FALSE;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B38_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE (a_mixed<json_value(a_nested, '$[6]' RETURNING varchar array)) IS NOT FALSE
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B39_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B39_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B39_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array));
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B39_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array))
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B39_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B39_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B39_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array))
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B39_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B39_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B39_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B40_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed NOT BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B40_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed NOT BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B40_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed NOT BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array));
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B40_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed NOT BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array))
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B40_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed NOT BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B40_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed NOT BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B40_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed NOT BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array))
+SELECT a_mixed
+FROM t1;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B40_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed NOT BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B40_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed NOT BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array);
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B40_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed NOT BETWEEN json_value(a_nested, '$[6]' RETURNING varchar array) AND json_value(a_nested, '$[7][6]' RETURNING varchar array)
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B41_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE array_to_string(a_mixed, ',') like '%';
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B41_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE array_to_string(a_mixed, ',') like '%'
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B41_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_mixed, ',') like '%');
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B41_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_mixed, ',') like '%')
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B41_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(a_mixed, ',') like '%';
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B41_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(a_mixed, ',') like '%'
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B41_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_mixed, ',') like '%')
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B41_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(a_mixed, ',') like '%')
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B41_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE array_to_string(a_mixed, ',') like '%';
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B41_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE array_to_string(a_mixed, ',') like '%'
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B42_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE array_to_string(json_value(a_nested, '$[6]' RETURNING varchar array), ',') not like '%';
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B42_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE array_to_string(json_value(a_nested, '$[6]' RETURNING varchar array), ',') not like '%'
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B42_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[6]' RETURNING varchar array), ',') not like '%');
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B42_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[6]' RETURNING varchar array), ',') not like '%')
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B42_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(json_value(a_nested, '$[6]' RETURNING varchar array), ',') not like '%';
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B42_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE array_to_string(json_value(a_nested, '$[6]' RETURNING varchar array), ',') not like '%'
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B42_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[6]' RETURNING varchar array), ',') not like '%')
+SELECT a_mixed
+FROM t1;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B42_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE array_to_string(json_value(a_nested, '$[6]' RETURNING varchar array), ',') not like '%')
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B42_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE array_to_string(json_value(a_nested, '$[6]' RETURNING varchar array), ',') not like '%';
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B42_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE array_to_string(json_value(a_nested, '$[6]' RETURNING varchar array), ',') not like '%'
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B43_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                  json_value(a_nested, '$[7][6]' RETURNING varchar array));
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B43_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                  json_value(a_nested, '$[7][6]' RETURNING varchar array))
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B43_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                     json_value(a_nested, '$[7][6]' RETURNING varchar array)));
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B43_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                     json_value(a_nested, '$[7][6]' RETURNING varchar array)))
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B43_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                  json_value(a_nested, '$[7][6]' RETURNING varchar array));
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B43_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                  json_value(a_nested, '$[7][6]' RETURNING varchar array))
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B43_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                     json_value(a_nested, '$[7][6]' RETURNING varchar array)))
+SELECT a_mixed
+FROM t1;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B43_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                     json_value(a_nested, '$[7][6]' RETURNING varchar array)))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B43_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                  json_value(a_nested, '$[7][6]' RETURNING varchar array));
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B43_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                  json_value(a_nested, '$[7][6]' RETURNING varchar array))
+GROUP BY a_mixed;
++--------------------------+-----+
+| a_mixed                  | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B44_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed NOT IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                      json_value(a_nested, '$[7][6]' RETURNING varchar array));
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B44_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed NOT IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                      json_value(a_nested, '$[7][6]' RETURNING varchar array))
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B44_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed NOT IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                         json_value(a_nested, '$[7][6]' RETURNING varchar array)));
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B44_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed NOT IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                         json_value(a_nested, '$[7][6]' RETURNING varchar array)))
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B44_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed NOT IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                      json_value(a_nested, '$[7][6]' RETURNING varchar array));
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B44_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed NOT IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                      json_value(a_nested, '$[7][6]' RETURNING varchar array))
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B44_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed NOT IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                         json_value(a_nested, '$[7][6]' RETURNING varchar array)))
+SELECT a_mixed
+FROM t1;
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B44_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed NOT IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                         json_value(a_nested, '$[7][6]' RETURNING varchar array)))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B44_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed NOT IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                      json_value(a_nested, '$[7][6]' RETURNING varchar array));
++---------+
+| a_mixed |
++---------+
++---------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B44_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed NOT IN (json_value(a_nested, '$[6]' RETURNING varchar array),
+                      json_value(a_nested, '$[7][6]' RETURNING varchar array))
+GROUP BY a_mixed;
++---------+-----+
+| a_mixed | cnt |
++---------+-----+
++---------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B45_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed IN
+    (SELECT a_mixed
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B45_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed IN
+    (SELECT a_mixed
+     FROM test_array)
+GROUP BY a_mixed;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B45_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed IN
+       (SELECT a_mixed
+        FROM test_array));
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B45_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed IN
+       (SELECT a_mixed
+        FROM test_array))
+GROUP BY a_mixed;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B45_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed IN
+    (SELECT a_mixed
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B45_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed IN
+    (SELECT a_mixed
+     FROM test_array)
+GROUP BY a_mixed;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B45_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed IN
+       (SELECT a_mixed
+        FROM test_array))
+SELECT a_mixed
+FROM t1;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B45_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed IN
+       (SELECT a_mixed
+        FROM test_array))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B45_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed IN
+    (SELECT a_mixed
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B45_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed IN
+    (SELECT a_mixed
+     FROM test_array)
+GROUP BY a_mixed;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B46_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM test_array
+WHERE a_mixed NOT IN
+    (SELECT a_mixed
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B46_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM test_array
+WHERE a_mixed NOT IN
+    (SELECT a_mixed
+     FROM test_array)
+GROUP BY a_mixed;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B46_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed NOT IN
+       (SELECT a_mixed
+        FROM test_array));
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B46_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed NOT IN
+       (SELECT a_mixed
+        FROM test_array))
+GROUP BY a_mixed;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B46_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed NOT IN
+    (SELECT a_mixed
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B46_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_mixed NOT IN
+    (SELECT a_mixed
+     FROM test_array)
+GROUP BY a_mixed;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B46_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed NOT IN
+       (SELECT a_mixed
+        FROM test_array))
+SELECT a_mixed
+FROM t1;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B46_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_mixed NOT IN
+       (SELECT a_mixed
+        FROM test_array))
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+GROUP BY a_mixed;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B46_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed
+FROM t1
+WHERE a_mixed NOT IN
+    (SELECT a_mixed
+     FROM test_array);
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A7_B46_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_mixed,
+       count(*) cnt
+FROM t1
+WHERE a_mixed NOT IN
+    (SELECT a_mixed
+     FROM test_array)
+GROUP BY a_mixed;
+ARRAY
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE a_nested=a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B1_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE a_nested=a_nested
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested=a_nested);
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B1_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested=a_nested)
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested=a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B1_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested=a_nested
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B1_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested=a_nested)
+SELECT a_nested
+FROM t1;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B1_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested=a_nested)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B1_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE a_nested=a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B1_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE a_nested=a_nested
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE a_nested<>a_nested;
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B2_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE a_nested<>a_nested
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested<>a_nested);
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B2_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested<>a_nested)
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested<>a_nested;
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B2_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested<>a_nested
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B2_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested<>a_nested)
+SELECT a_nested
+FROM t1;
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B2_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested<>a_nested)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B2_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE a_nested<>a_nested;
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B2_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE a_nested<>a_nested
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B3_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE a_nested>a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B3_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE a_nested>a_nested
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B3_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested>a_nested);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B3_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested>a_nested)
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B3_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested>a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B3_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested>a_nested
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B3_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested>a_nested)
+SELECT a_nested
+FROM t1;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B3_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested>a_nested)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B3_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE a_nested>a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B3_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE a_nested>a_nested
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B4_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE a_nested>=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B4_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE a_nested>=a_nested
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B4_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested>=a_nested);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B4_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested>=a_nested)
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B4_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested>=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B4_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested>=a_nested
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B4_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested>=a_nested)
+SELECT a_nested
+FROM t1;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B4_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested>=a_nested)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B4_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE a_nested>=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B4_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE a_nested>=a_nested
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B5_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE a_nested<a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B5_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE a_nested<a_nested
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B5_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested<a_nested);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B5_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested<a_nested)
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B5_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested<a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B5_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested<a_nested
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B5_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested<a_nested)
+SELECT a_nested
+FROM t1;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B5_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested<a_nested)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B5_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE a_nested<a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B5_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE a_nested<a_nested
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B6_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE a_nested<=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B6_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE a_nested<=a_nested
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B6_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested<=a_nested);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B6_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested<=a_nested)
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B6_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested<=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B6_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested<=a_nested
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B6_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested<=a_nested)
+SELECT a_nested
+FROM t1;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B6_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested<=a_nested)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B6_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE a_nested<=a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B6_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE a_nested<=a_nested
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE a_nested=a_nested
+  OR a_nested<>a_nested
+  AND NOT (a_nested=a_nested
+           AND a_nested<>a_nested);
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B7_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE a_nested=a_nested
+  OR a_nested<>a_nested
+  AND NOT (a_nested=a_nested
+           AND a_nested<>a_nested)
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested=a_nested
+     OR a_nested<>a_nested
+     AND NOT (a_nested=a_nested
+              AND a_nested<>a_nested));
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B7_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested=a_nested
+     OR a_nested<>a_nested
+     AND NOT (a_nested=a_nested
+              AND a_nested<>a_nested))
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B7_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested=a_nested
+  OR a_nested<>a_nested
+  AND NOT (a_nested=a_nested
+           AND a_nested<>a_nested);
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B7_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested=a_nested
+  OR a_nested<>a_nested
+  AND NOT (a_nested=a_nested
+           AND a_nested<>a_nested)
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B7_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested=a_nested
+     OR a_nested<>a_nested
+     AND NOT (a_nested=a_nested
+              AND a_nested<>a_nested))
+SELECT a_nested
+FROM t1;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B7_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested=a_nested
+     OR a_nested<>a_nested
+     AND NOT (a_nested=a_nested
+              AND a_nested<>a_nested))
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B7_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE a_nested=a_nested
+  OR a_nested<>a_nested
+  AND NOT (a_nested=a_nested
+           AND a_nested<>a_nested);
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B7_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE a_nested=a_nested
+  OR a_nested<>a_nested
+  AND NOT (a_nested=a_nested
+           AND a_nested<>a_nested)
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE NOT (a_nested<>a_nested)
+  OR NOT (a_nested=a_nested)
+  OR a_nested=a_nested
+  OR a_nested<>a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B8_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE NOT (a_nested<>a_nested)
+  OR NOT (a_nested=a_nested)
+  OR a_nested=a_nested
+  OR a_nested<>a_nested
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_nested<>a_nested)
+     OR NOT (a_nested=a_nested)
+     OR a_nested=a_nested
+     OR a_nested<>a_nested);
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B8_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_nested<>a_nested)
+     OR NOT (a_nested=a_nested)
+     OR a_nested=a_nested
+     OR a_nested<>a_nested)
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B8_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE NOT (a_nested<>a_nested)
+  OR NOT (a_nested=a_nested)
+  OR a_nested=a_nested
+  OR a_nested<>a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B8_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE NOT (a_nested<>a_nested)
+  OR NOT (a_nested=a_nested)
+  OR a_nested=a_nested
+  OR a_nested<>a_nested
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B8_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_nested<>a_nested)
+     OR NOT (a_nested=a_nested)
+     OR a_nested=a_nested
+     OR a_nested<>a_nested)
+SELECT a_nested
+FROM t1;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B8_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE NOT (a_nested<>a_nested)
+     OR NOT (a_nested=a_nested)
+     OR a_nested=a_nested
+     OR a_nested<>a_nested)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B8_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE NOT (a_nested<>a_nested)
+  OR NOT (a_nested=a_nested)
+  OR a_nested=a_nested
+  OR a_nested<>a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B8_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE NOT (a_nested<>a_nested)
+  OR NOT (a_nested=a_nested)
+  OR a_nested=a_nested
+  OR a_nested<>a_nested
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B9_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE a_nested IS NULL;
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B9_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE a_nested IS NULL
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B9_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested IS NULL);
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B9_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested IS NULL)
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B9_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested IS NULL;
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B9_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested IS NULL
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B9_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested IS NULL)
+SELECT a_nested
+FROM t1;
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B9_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested IS NULL)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B9_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE a_nested IS NULL;
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B9_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE a_nested IS NULL
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B10_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE a_nested IS NOT NULL;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B10_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE a_nested IS NOT NULL
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B10_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested IS NOT NULL);
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B10_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested IS NOT NULL)
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B10_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested IS NOT NULL;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B10_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested IS NOT NULL
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B10_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested IS NOT NULL)
+SELECT a_nested
+FROM t1;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B10_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested IS NOT NULL)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B10_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE a_nested IS NOT NULL;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B10_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE a_nested IS NOT NULL
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B11_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE (a_nested=a_nested) IS TRUE;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B11_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE (a_nested=a_nested) IS TRUE
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B11_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_nested=a_nested) IS TRUE);
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B11_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_nested=a_nested) IS TRUE)
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B11_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_nested=a_nested) IS TRUE;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B11_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_nested=a_nested) IS TRUE
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B11_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_nested=a_nested) IS TRUE)
+SELECT a_nested
+FROM t1;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B11_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_nested=a_nested) IS TRUE)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B11_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE (a_nested=a_nested) IS TRUE;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B11_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE (a_nested=a_nested) IS TRUE
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B12_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE (a_nested=a_nested) IS NOT TRUE;
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B12_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE (a_nested=a_nested) IS NOT TRUE
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B12_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_nested=a_nested) IS NOT TRUE);
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B12_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_nested=a_nested) IS NOT TRUE)
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B12_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_nested=a_nested) IS NOT TRUE;
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B12_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_nested=a_nested) IS NOT TRUE
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B12_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_nested=a_nested) IS NOT TRUE)
+SELECT a_nested
+FROM t1;
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B12_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_nested=a_nested) IS NOT TRUE)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B12_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE (a_nested=a_nested) IS NOT TRUE;
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B12_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE (a_nested=a_nested) IS NOT TRUE
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B13_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE (a_nested=a_nested) IS FALSE;
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B13_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE (a_nested=a_nested) IS FALSE
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B13_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_nested=a_nested) IS FALSE);
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B13_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_nested=a_nested) IS FALSE)
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B13_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_nested=a_nested) IS FALSE;
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B13_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_nested=a_nested) IS FALSE
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B13_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_nested=a_nested) IS FALSE)
+SELECT a_nested
+FROM t1;
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B13_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_nested=a_nested) IS FALSE)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B13_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE (a_nested=a_nested) IS FALSE;
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B13_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE (a_nested=a_nested) IS FALSE
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B14_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE (a_nested=a_nested) IS NOT FALSE;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B14_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE (a_nested=a_nested) IS NOT FALSE
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B14_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_nested=a_nested) IS NOT FALSE);
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B14_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE (a_nested=a_nested) IS NOT FALSE)
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B14_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_nested=a_nested) IS NOT FALSE;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B14_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE (a_nested=a_nested) IS NOT FALSE
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B14_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_nested=a_nested) IS NOT FALSE)
+SELECT a_nested
+FROM t1;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B14_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE (a_nested=a_nested) IS NOT FALSE)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B14_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE (a_nested=a_nested) IS NOT FALSE;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B14_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE (a_nested=a_nested) IS NOT FALSE
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B15_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE a_nested BETWEEN a_nested AND a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B15_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE a_nested BETWEEN a_nested AND a_nested
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B15_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested BETWEEN a_nested AND a_nested);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B15_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested BETWEEN a_nested AND a_nested)
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B15_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested BETWEEN a_nested AND a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B15_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested BETWEEN a_nested AND a_nested
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B15_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested BETWEEN a_nested AND a_nested)
+SELECT a_nested
+FROM t1;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B15_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested BETWEEN a_nested AND a_nested)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B15_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE a_nested BETWEEN a_nested AND a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B15_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE a_nested BETWEEN a_nested AND a_nested
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B16_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE a_nested NOT BETWEEN a_nested AND a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B16_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE a_nested NOT BETWEEN a_nested AND a_nested
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B16_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested NOT BETWEEN a_nested AND a_nested);
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B16_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested NOT BETWEEN a_nested AND a_nested)
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B16_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested NOT BETWEEN a_nested AND a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B16_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested NOT BETWEEN a_nested AND a_nested
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B16_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested NOT BETWEEN a_nested AND a_nested)
+SELECT a_nested
+FROM t1;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B16_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested NOT BETWEEN a_nested AND a_nested)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B16_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE a_nested NOT BETWEEN a_nested AND a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B16_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE a_nested NOT BETWEEN a_nested AND a_nested
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B17_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE a_nested like '%';
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B17_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE a_nested like '%'
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B17_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested like '%');
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B17_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested like '%')
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B17_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested like '%';
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B17_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested like '%'
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B17_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested like '%')
+SELECT a_nested
+FROM t1;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B17_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested like '%')
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B17_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE a_nested like '%';
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B17_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE a_nested like '%'
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B18_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE a_nested not like '%';
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B18_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE a_nested not like '%'
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B18_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested not like '%');
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B18_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested not like '%')
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B18_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested not like '%';
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B18_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested not like '%'
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B18_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested not like '%')
+SELECT a_nested
+FROM t1;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B18_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested not like '%')
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B18_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE a_nested not like '%';
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B18_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE a_nested not like '%'
+GROUP BY a_nested;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B19_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE a_nested IN (a_nested,
+                   a_nested);
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B19_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE a_nested IN (a_nested,
+                   a_nested)
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B19_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested IN (a_nested,
+                      a_nested));
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B19_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested IN (a_nested,
+                      a_nested))
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B19_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested IN (a_nested,
+                   a_nested);
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B19_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested IN (a_nested,
+                   a_nested)
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B19_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested IN (a_nested,
+                      a_nested))
+SELECT a_nested
+FROM t1;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B19_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested IN (a_nested,
+                      a_nested))
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B19_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE a_nested IN (a_nested,
+                   a_nested);
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B19_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE a_nested IN (a_nested,
+                   a_nested)
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| a_nested                                                                                                                                                                                                                                                                                                                      | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B20_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE a_nested NOT IN (a_nested,
+                       a_nested);
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B20_C2 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE a_nested NOT IN (a_nested,
+                       a_nested)
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B20_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested NOT IN (a_nested,
+                          a_nested));
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B20_C4 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested NOT IN (a_nested,
+                          a_nested))
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B20_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested NOT IN (a_nested,
+                       a_nested);
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B20_C6 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested NOT IN (a_nested,
+                       a_nested)
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B20_C7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested NOT IN (a_nested,
+                          a_nested))
+SELECT a_nested
+FROM t1;
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B20_C8 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested NOT IN (a_nested,
+                          a_nested))
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B20_C9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE a_nested NOT IN (a_nested,
+                       a_nested);
++----------+
+| a_nested |
++----------+
++----------+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B20_C10 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE a_nested NOT IN (a_nested,
+                       a_nested)
+GROUP BY a_nested;
++----------+-----+
+| a_nested | cnt |
++----------+-----+
++----------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B21_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE a_nested IN
+    (SELECT a_nested
+     FROM test_array);
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B21_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE a_nested IN
+    (SELECT a_nested
+     FROM test_array)
+GROUP BY a_nested;
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B21_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested IN
+       (SELECT a_nested
+        FROM test_array));
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B21_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested IN
+       (SELECT a_nested
+        FROM test_array))
+GROUP BY a_nested;
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B21_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested IN
+    (SELECT a_nested
+     FROM test_array);
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B21_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested IN
+    (SELECT a_nested
+     FROM test_array)
+GROUP BY a_nested;
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B21_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested IN
+       (SELECT a_nested
+        FROM test_array))
+SELECT a_nested
+FROM t1;
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B21_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested IN
+       (SELECT a_nested
+        FROM test_array))
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B21_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE a_nested IN
+    (SELECT a_nested
+     FROM test_array);
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B21_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE a_nested IN
+    (SELECT a_nested
+     FROM test_array)
+GROUP BY a_nested;
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B22_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM test_array
+WHERE a_nested NOT IN
+    (SELECT a_nested
+     FROM test_array);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B22_C2 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM test_array
+WHERE a_nested NOT IN
+    (SELECT a_nested
+     FROM test_array)
+GROUP BY a_nested;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B22_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested NOT IN
+       (SELECT a_nested
+        FROM test_array));
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B22_C4 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array
+   WHERE a_nested NOT IN
+       (SELECT a_nested
+        FROM test_array))
+GROUP BY a_nested;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B22_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested NOT IN
+    (SELECT a_nested
+     FROM test_array);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B22_C6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested,
+       count(*) cnt
+FROM
+  (SELECT *
+   FROM test_array)
+WHERE a_nested NOT IN
+    (SELECT a_nested
+     FROM test_array)
+GROUP BY a_nested;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B22_C7 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested NOT IN
+       (SELECT a_nested
+        FROM test_array))
+SELECT a_nested
+FROM t1;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B22_C8 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array
+   WHERE a_nested NOT IN
+       (SELECT a_nested
+        FROM test_array))
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+GROUP BY a_nested;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B22_C9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested
+FROM t1
+WHERE a_nested NOT IN
+    (SELECT a_nested
+     FROM test_array);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_subquery_with_where TEST_ID: A8_B22_C10 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT a_nested,
+       count(*) cnt
+FROM t1
+WHERE a_nested NOT IN
+    (SELECT a_nested
+     FROM test_array)
+GROUP BY a_nested;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_bool;
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (a_bool);
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(a_bool);
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
+|              |   4 |
++--------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(a_bool);
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
+|              |   4 |
++--------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A1_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_bool
+HAVING a_bool=ARRAY[1,
+                    0,
+                    NULL];
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_int;
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (a_int);
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(a_int);
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
+|              |   4 |
++--------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(a_int);
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
+|              |   4 |
++--------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A4_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_int
+HAVING a_int=ARRAY[1,
+                   2,
+                   NULL];
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[1]' RETURNING bigint array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array);
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[1]' RETURNING bigint array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (json_value(a_nested, '$[1]' RETURNING bigint array));
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[1]' RETURNING bigint array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(json_value(a_nested, '$[1]' RETURNING bigint array));
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
+|              |   4 |
++--------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[1]' RETURNING bigint array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(json_value(a_nested, '$[1]' RETURNING bigint array));
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
+|              |   4 |
++--------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A5_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[1]' RETURNING bigint array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array)
+HAVING json_value(a_nested, '$[1]' RETURNING bigint array)=ARRAY[1,
+                                                                 2,
+                                                                 NULL];
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][1]' RETURNING bigint array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array);
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][1]' RETURNING bigint array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (json_value(a_nested, '$[7][1]' RETURNING bigint array));
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][1]' RETURNING bigint array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(json_value(a_nested, '$[7][1]' RETURNING bigint array));
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
+|              |   4 |
++--------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][1]' RETURNING bigint array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(json_value(a_nested, '$[7][1]' RETURNING bigint array));
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
+|              |   4 |
++--------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A6_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][1]' RETURNING bigint array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+HAVING json_value(a_nested, '$[7][1]' RETURNING bigint array)=ARRAY[1,
+                                                                    2,
+                                                                    NULL];
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
++--------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_float;
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (a_float);
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(a_float);
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
+|                  |   4 |
++------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(a_float);
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
+|                  |   4 |
++------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A7_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_float
+HAVING a_float=ARRAY[0.1,
+                     0.2,
+                     NULL];
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A8_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[2]' RETURNING decimal array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array);
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A8_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[2]' RETURNING decimal array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (json_value(a_nested, '$[2]' RETURNING decimal array));
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A8_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[2]' RETURNING decimal array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(json_value(a_nested, '$[2]' RETURNING decimal array));
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
+|                  |   4 |
++------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A8_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[2]' RETURNING decimal array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(json_value(a_nested, '$[2]' RETURNING decimal array));
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
+|                  |   4 |
++------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A8_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[2]' RETURNING decimal array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array)
+HAVING json_value(a_nested, '$[2]' RETURNING decimal array)=ARRAY[0.1,
+                                                                  0.2,
+                                                                  NULL];
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A9_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][2]' RETURNING decimal array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array);
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A9_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][2]' RETURNING decimal array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (json_value(a_nested, '$[7][2]' RETURNING decimal array));
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A9_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][2]' RETURNING decimal array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(json_value(a_nested, '$[7][2]' RETURNING decimal array));
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
+|                  |   4 |
++------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A9_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][2]' RETURNING decimal array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(json_value(a_nested, '$[7][2]' RETURNING decimal array));
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
+|                  |   4 |
++------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A9_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][2]' RETURNING decimal array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+HAVING json_value(a_nested, '$[7][2]' RETURNING decimal array)=ARRAY[0.1,
+                                                                     0.2,
+                                                                     NULL];
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A10_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_str;
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A10_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (a_str);
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A10_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(a_str);
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
+|                |   4 |
++----------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A10_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(a_str);
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
+|                |   4 |
++----------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A10_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_str
+HAVING a_str=ARRAY['S1',
+                   'S2',
+                   NULL];
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A11_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[3]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array);
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A11_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[3]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (json_value(a_nested, '$[3]' RETURNING varchar array));
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A11_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[3]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(json_value(a_nested, '$[3]' RETURNING varchar array));
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
+|                |   4 |
++----------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A11_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[3]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(json_value(a_nested, '$[3]' RETURNING varchar array));
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
+|                |   4 |
++----------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A11_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[3]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array)
+HAVING json_value(a_nested, '$[3]' RETURNING varchar array)=ARRAY['S1',
+                                                                  'S2',
+                                                                  NULL];
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A12_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][3]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array);
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A12_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][3]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (json_value(a_nested, '$[7][3]' RETURNING varchar array));
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A12_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][3]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(json_value(a_nested, '$[7][3]' RETURNING varchar array));
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
+|                |   4 |
++----------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A12_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][3]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(json_value(a_nested, '$[7][3]' RETURNING varchar array));
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
+|                |   4 |
++----------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A12_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][3]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING json_value(a_nested, '$[7][3]' RETURNING varchar array)=ARRAY['S1',
+                                                                     'S2',
+                                                                     NULL];
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
++----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A13_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_null;
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
++--------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A13_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (a_null);
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
++--------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A13_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(a_null);
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
+|                    |   4 |
++--------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A13_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(a_null);
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
+|                    |   4 |
++--------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A13_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_null
+HAVING a_null=ARRAY[NULL,
+                    NULL,
+                    NULL];
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
++--------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A14_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[4]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array);
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
++--------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A14_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[4]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (json_value(a_nested, '$[4]' RETURNING varchar array));
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
++--------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A14_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[4]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(json_value(a_nested, '$[4]' RETURNING varchar array));
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
+|                    |   4 |
++--------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A14_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[4]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(json_value(a_nested, '$[4]' RETURNING varchar array));
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
+|                    |   4 |
++--------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A14_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[4]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array)
+HAVING json_value(a_nested, '$[4]' RETURNING varchar array)=ARRAY[NULL,
+                                                                  NULL,
+                                                                  NULL];
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
++--------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A15_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][4]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array);
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
++--------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A15_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][4]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (json_value(a_nested, '$[7][4]' RETURNING varchar array));
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
++--------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A15_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][4]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(json_value(a_nested, '$[7][4]' RETURNING varchar array));
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
+|                    |   4 |
++--------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A15_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][4]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(json_value(a_nested, '$[7][4]' RETURNING varchar array));
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
+|                    |   4 |
++--------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A15_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][4]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+HAVING json_value(a_nested, '$[7][4]' RETURNING varchar array)=ARRAY[NULL,
+                                                                     NULL,
+                                                                     NULL];
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
++--------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A16_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_empty;
++----+-----+
+| c  | cnt |
++----+-----+
+| [] |   4 |
++----+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A16_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (a_empty);
++----+-----+
+| c  | cnt |
++----+-----+
+| [] |   4 |
++----+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A16_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(a_empty);
++----+-----+
+| c  | cnt |
++----+-----+
+| [] |   4 |
+|    |   4 |
++----+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A16_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(a_empty);
++----+-----+
+| c  | cnt |
++----+-----+
+| [] |   4 |
+|    |   4 |
++----+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A16_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_empty
+HAVING a_empty=ARRAY['A'];
++---+-----+
+| c | cnt |
++---+-----+
++---+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A17_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[5]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array);
++----+-----+
+| c  | cnt |
++----+-----+
+| [] |   4 |
++----+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A17_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[5]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (json_value(a_nested, '$[5]' RETURNING varchar array));
++----+-----+
+| c  | cnt |
++----+-----+
+| [] |   4 |
++----+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A17_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[5]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(json_value(a_nested, '$[5]' RETURNING varchar array));
++----+-----+
+| c  | cnt |
++----+-----+
+| [] |   4 |
+|    |   4 |
++----+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A17_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[5]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(json_value(a_nested, '$[5]' RETURNING varchar array));
++----+-----+
+| c  | cnt |
++----+-----+
+| [] |   4 |
+|    |   4 |
++----+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A17_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[5]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array)
+HAVING json_value(a_nested, '$[5]' RETURNING varchar array)=ARRAY['A'];
++---+-----+
+| c | cnt |
++---+-----+
++---+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A18_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][5]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array);
++----+-----+
+| c  | cnt |
++----+-----+
+| [] |   4 |
++----+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A18_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][5]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (json_value(a_nested, '$[7][5]' RETURNING varchar array));
++----+-----+
+| c  | cnt |
++----+-----+
+| [] |   4 |
++----+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A18_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][5]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(json_value(a_nested, '$[7][5]' RETURNING varchar array));
++----+-----+
+| c  | cnt |
++----+-----+
+| [] |   4 |
+|    |   4 |
++----+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A18_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][5]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(json_value(a_nested, '$[7][5]' RETURNING varchar array));
++----+-----+
+| c  | cnt |
++----+-----+
+| [] |   4 |
+|    |   4 |
++----+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A18_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][5]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+HAVING json_value(a_nested, '$[7][5]' RETURNING varchar array)=ARRAY['A'];
++---+-----+
+| c | cnt |
++---+-----+
++---+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A19_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_mixed;
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A19_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (a_mixed);
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A19_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(a_mixed);
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
+|                          |   4 |
++--------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A19_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(a_mixed);
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
+|                          |   4 |
++--------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A19_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_mixed
+HAVING a_mixed=ARRAY['true',
+                     '1',
+                     '0.1',
+                     'S1',
+                     NULL];
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A20_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[6]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array);
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A20_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[6]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (json_value(a_nested, '$[6]' RETURNING varchar array));
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A20_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[6]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(json_value(a_nested, '$[6]' RETURNING varchar array));
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
+|                          |   4 |
++--------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A20_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[6]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(json_value(a_nested, '$[6]' RETURNING varchar array));
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
+|                          |   4 |
++--------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A20_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[6]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array)
+HAVING json_value(a_nested, '$[6]' RETURNING varchar array)=ARRAY['true',
+                                                                  '1',
+                                                                  '0.1',
+                                                                  'S1',
+                                                                  NULL];
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A21_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][6]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array);
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A21_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][6]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (json_value(a_nested, '$[7][6]' RETURNING varchar array));
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A21_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][6]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(json_value(a_nested, '$[7][6]' RETURNING varchar array));
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
+|                          |   4 |
++--------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A21_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][6]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(json_value(a_nested, '$[7][6]' RETURNING varchar array));
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
+|                          |   4 |
++--------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A21_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][6]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+HAVING json_value(a_nested, '$[7][6]' RETURNING varchar array)=ARRAY['true',
+                                                                     '1',
+                                                                     '0.1',
+                                                                     'S1',
+                                                                     NULL];
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A22_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_nested;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| c                                                                                                                                                                                                                                                                                                                             | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A22_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (a_nested);
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| c                                                                                                                                                                                                                                                                                                                             | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A22_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(a_nested);
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| c                                                                                                                                                                                                                                                                                                                             | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
+|                                                                                                                                                                                                                                                                                                                               |   4 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A22_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(a_nested);
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| c                                                                                                                                                                                                                                                                                                                             | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
+|                                                                                                                                                                                                                                                                                                                               |   4 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A22_B9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_nested
+HAVING a_nested=ARRAY[NULL,
+                      NULL,
+                      NULL];
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A23_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_nested, '$[7]') c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_query(a_nested, '$[7]');
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| c                                                                                                                                                                                                                   | cnt |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]] |   2 |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A23_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_nested, '$[7]') c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (json_query(a_nested, '$[7]'));
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| c                                                                                                                                                                                                                   | cnt |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]] |   2 |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A23_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_nested, '$[7]') c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(json_query(a_nested, '$[7]'));
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| c                                                                                                                                                                                                                   | cnt |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]] |   2 |
+|                                                                                                                                                                                                                     |   4 |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A23_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_nested, '$[7]') c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(json_query(a_nested, '$[7]'));
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| c                                                                                                                                                                                                                   | cnt |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]] |   2 |
+|                                                                                                                                                                                                                     |   4 |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A23_B9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_nested, '$[7]') c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_query(a_nested, '$[7]')
+HAVING json_query(a_nested, '$[7]')=ARRAY[NULL,
+                                          NULL,
+                                          NULL];
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A24_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_nested, '$[7][7]') c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_query(a_nested, '$[7][7]');
++-----------------------------------------------------------------------------------------------------------+-----+
+| c                                                                                                         | cnt |
++-----------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]] |   2 |
++-----------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A24_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_nested, '$[7][7]') c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (json_query(a_nested, '$[7][7]'));
++-----------------------------------------------------------------------------------------------------------+-----+
+| c                                                                                                         | cnt |
++-----------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]] |   2 |
++-----------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A24_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_nested, '$[7][7]') c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(json_query(a_nested, '$[7][7]'));
++-----------------------------------------------------------------------------------------------------------+-----+
+| c                                                                                                         | cnt |
++-----------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]] |   2 |
+|                                                                                                           |   4 |
++-----------------------------------------------------------------------------------------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A24_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_nested, '$[7][7]') c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(json_query(a_nested, '$[7][7]'));
++-----------------------------------------------------------------------------------------------------------+-----+
+| c                                                                                                         | cnt |
++-----------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]] |   2 |
+|                                                                                                           |   4 |
++-----------------------------------------------------------------------------------------------------------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A24_B9 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_nested, '$[7][7]') c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_query(a_nested, '$[7][7]')
+HAVING json_query(a_nested, '$[7][7]')=ARRAY[NULL,
+                                             NULL,
+                                             NULL];
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A25_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       json_value(a_nested, '$[2]' RETURNING decimal array),
+       json_value(a_nested, '$[7][3]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_int,
+         json_value(a_nested, '$[2]' RETURNING decimal array),
+         json_value(a_nested, '$[7][3]' RETURNING varchar array);
++--------------+------------------+----------------+-----+
+| a_int        | EXPR$1           | c              | cnt |
++--------------+------------------+----------------+-----+
+| [1, 2, null] | [0.1, 0.2, null] | [S1, S2, null] |   2 |
+| [null, 2, 1] | [null, 0.2, 0.1] | [null, S2, S1] |   2 |
++--------------+------------------+----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A25_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       json_value(a_nested, '$[2]' RETURNING decimal array),
+       json_value(a_nested, '$[7][3]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY GROUPING
+SETS (a_int,
+      json_value(a_nested, '$[2]' RETURNING decimal array),
+      json_value(a_nested, '$[7][3]' RETURNING varchar array));
++--------------+------------------+----------------+-----+
+| a_int        | EXPR$1           | c              | cnt |
++--------------+------------------+----------------+-----+
+| [1, 2, null] |                  |                |   2 |
+| [null, 2, 1] |                  |                |   2 |
+|              | [0.1, 0.2, null] |                |   2 |
+|              | [null, 0.2, 0.1] |                |   2 |
+|              |                  | [S1, S2, null] |   2 |
+|              |                  | [null, S2, S1] |   2 |
++--------------+------------------+----------------+-----+
+(6 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A25_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       json_value(a_nested, '$[2]' RETURNING decimal array),
+       json_value(a_nested, '$[7][3]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY rollup(a_int, json_value(a_nested, '$[2]' RETURNING decimal array), json_value(a_nested, '$[7][3]' RETURNING varchar array));
++--------------+------------------+----------------+-----+
+| a_int        | EXPR$1           | c              | cnt |
++--------------+------------------+----------------+-----+
+| [1, 2, null] | [0.1, 0.2, null] | [S1, S2, null] |   2 |
+| [1, 2, null] | [0.1, 0.2, null] |                |   2 |
+| [1, 2, null] |                  |                |   2 |
+| [null, 2, 1] | [null, 0.2, 0.1] | [null, S2, S1] |   2 |
+| [null, 2, 1] | [null, 0.2, 0.1] |                |   2 |
+| [null, 2, 1] |                  |                |   2 |
+|              |                  |                |   4 |
++--------------+------------------+----------------+-----+
+(7 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A25_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       json_value(a_nested, '$[2]' RETURNING decimal array),
+       json_value(a_nested, '$[7][3]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY cube(a_int, json_value(a_nested, '$[2]' RETURNING decimal array), json_value(a_nested, '$[7][3]' RETURNING varchar array));
++--------------+------------------+----------------+-----+
+| a_int        | EXPR$1           | c              | cnt |
++--------------+------------------+----------------+-----+
+| [1, 2, null] | [0.1, 0.2, null] | [S1, S2, null] |   2 |
+| [1, 2, null] | [0.1, 0.2, null] |                |   2 |
+| [1, 2, null] |                  | [S1, S2, null] |   2 |
+| [1, 2, null] |                  |                |   2 |
+| [null, 2, 1] | [null, 0.2, 0.1] | [null, S2, S1] |   2 |
+| [null, 2, 1] | [null, 0.2, 0.1] |                |   2 |
+| [null, 2, 1] |                  | [null, S2, S1] |   2 |
+| [null, 2, 1] |                  |                |   2 |
+|              | [0.1, 0.2, null] | [S1, S2, null] |   2 |
+|              | [0.1, 0.2, null] |                |   2 |
+|              | [null, 0.2, 0.1] | [null, S2, S1] |   2 |
+|              | [null, 0.2, 0.1] |                |   2 |
+|              |                  | [S1, S2, null] |   2 |
+|              |                  | [null, S2, S1] |   2 |
+|              |                  |                |   4 |
++--------------+------------------+----------------+-----+
+(15 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_group_by TEST_ID: A25_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int,
+       json_value(a_nested, '$[2]' RETURNING decimal array),
+       json_value(a_nested, '$[7][3]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_int,
+         json_value(a_nested, '$[2]' RETURNING decimal array),
+         json_value(a_nested, '$[7][3]' RETURNING varchar array)
+HAVING a_int=ARRAY[1,
+                   2,
+                   NULL]
+AND json_value(a_nested, '$[2]' RETURNING decimal array)=ARRAY[0.1,
+                                                               0.2,
+                                                               NULL]
+AND json_value(a_nested, '$[7][3]' RETURNING varchar array)=ARRAY['S1',
+                                                                  'S2',
+                                                                  NULL];
++--------------+------------------+----------------+-----+
+| a_int        | EXPR$1           | c              | cnt |
++--------------+------------------+----------------+-----+
+| [1, 2, null] | [0.1, 0.2, null] | [S1, S2, null] |   2 |
++--------------+------------------+----------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_array
+GROUP BY __time
+ORDER BY __time ASC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-01-01 00:00:00.000 |   2 |
+| 2022-02-01 00:00:00.000 |   2 |
++-------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time,
+       count(*) cnt
+FROM test_array
+GROUP BY __time
+ORDER BY __time DESC;
++-------------------------+-----+
+| __time                  | cnt |
++-------------------------+-----+
+| 2022-02-01 00:00:00.000 |   2 |
+| 2022-01-01 00:00:00.000 |   2 |
++-------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_array
+ORDER BY __time ASC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
++-------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM test_array
+ORDER BY 1 DESC;
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
++-------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_array
+   ORDER BY __time ASC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
++-------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A1_B11 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT __time
+FROM
+  (SELECT __time
+   FROM test_array
+   ORDER BY 1 DESC);
++-------------------------+
+| __time                  |
++-------------------------+
+| 2022-01-01 00:00:00.000 |
+| 2022-01-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
+| 2022-02-01 00:00:00.000 |
++-------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_bool
+ORDER BY a_bool ASC;
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [null, 0, 1] |   2 |
+| [1, 0, null] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 0, null] |   2 |
+| [null, 0, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_bool c
+   FROM test_array
+   ORDER BY c ASC);
++--------------+
+| c            |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A2_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_bool c
+   FROM test_array
+   ORDER BY 1 DESC);
++--------------+
+| c            |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_int
+ORDER BY a_int ASC;
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
+| [1, 2, null] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_int c
+   FROM test_array
+   ORDER BY c ASC);
++--------------+
+| c            |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A5_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_int c
+   FROM test_array
+   ORDER BY 1 DESC);
++--------------+
+| c            |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[1]' RETURNING bigint array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[1]' RETURNING bigint array)
+ORDER BY json_value(a_nested, '$[1]' RETURNING bigint array) ASC;
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
+| [1, 2, null] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[1]' RETURNING bigint array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[1]' RETURNING bigint array) c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[1]' RETURNING bigint array) c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[1]' RETURNING bigint array) c
+   FROM test_array
+   ORDER BY c ASC);
++--------------+
+| c            |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A6_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[1]' RETURNING bigint array) c
+   FROM test_array
+   ORDER BY 1 DESC);
++--------------+
+| c            |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][1]' RETURNING bigint array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][1]' RETURNING bigint array)
+ORDER BY json_value(a_nested, '$[7][1]' RETURNING bigint array) ASC;
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [null, 2, 1] |   2 |
+| [1, 2, null] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][1]' RETURNING bigint array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++--------------+-----+
+| c            | cnt |
++--------------+-----+
+| [1, 2, null] |   2 |
+| [null, 2, 1] |   2 |
++--------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][1]' RETURNING bigint array) c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][1]' RETURNING bigint array) c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7][1]' RETURNING bigint array) c
+   FROM test_array
+   ORDER BY c ASC);
++--------------+
+| c            |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A7_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7][1]' RETURNING bigint array) c
+   FROM test_array
+   ORDER BY 1 DESC);
++--------------+
+| c            |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_float
+ORDER BY a_float ASC;
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_float c
+   FROM test_array
+   ORDER BY c ASC);
++------------------+
+| c                |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A8_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_float c
+   FROM test_array
+   ORDER BY 1 DESC);
++------------------+
+| c                |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[2]' RETURNING decimal array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[2]' RETURNING decimal array)
+ORDER BY json_value(a_nested, '$[2]' RETURNING decimal array) ASC;
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[2]' RETURNING decimal array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[2]' RETURNING decimal array) c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[2]' RETURNING decimal array) c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[2]' RETURNING decimal array) c
+   FROM test_array
+   ORDER BY c ASC);
++------------------+
+| c                |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A9_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[2]' RETURNING decimal array) c
+   FROM test_array
+   ORDER BY 1 DESC);
++------------------+
+| c                |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][2]' RETURNING decimal array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][2]' RETURNING decimal array)
+ORDER BY json_value(a_nested, '$[7][2]' RETURNING decimal array) ASC;
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [null, 0.2, 0.1] |   2 |
+| [0.1, 0.2, null] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][2]' RETURNING decimal array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++------------------+-----+
+| c                | cnt |
++------------------+-----+
+| [0.1, 0.2, null] |   2 |
+| [null, 0.2, 0.1] |   2 |
++------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][2]' RETURNING decimal array) c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][2]' RETURNING decimal array) c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7][2]' RETURNING decimal array) c
+   FROM test_array
+   ORDER BY c ASC);
++------------------+
+| c                |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A10_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7][2]' RETURNING decimal array) c
+   FROM test_array
+   ORDER BY 1 DESC);
++------------------+
+| c                |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_str
+ORDER BY a_str ASC;
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
+| [S1, S2, null] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_str c
+   FROM test_array
+   ORDER BY c ASC);
++----------------+
+| c              |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A11_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_str c
+   FROM test_array
+   ORDER BY 1 DESC);
++----------------+
+| c              |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[3]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[3]' RETURNING varchar array)
+ORDER BY json_value(a_nested, '$[3]' RETURNING varchar array) ASC;
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
+| [S1, S2, null] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[3]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[3]' RETURNING varchar array) c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[3]' RETURNING varchar array) c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[3]' RETURNING varchar array) c
+   FROM test_array
+   ORDER BY c ASC);
++----------------+
+| c              |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A12_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[3]' RETURNING varchar array) c
+   FROM test_array
+   ORDER BY 1 DESC);
++----------------+
+| c              |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A13_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][3]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][3]' RETURNING varchar array)
+ORDER BY json_value(a_nested, '$[7][3]' RETURNING varchar array) ASC;
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [null, S2, S1] |   2 |
+| [S1, S2, null] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A13_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][3]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++----------------+-----+
+| c              | cnt |
++----------------+-----+
+| [S1, S2, null] |   2 |
+| [null, S2, S1] |   2 |
++----------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A13_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][3]' RETURNING varchar array) c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A13_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][3]' RETURNING varchar array) c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A13_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7][3]' RETURNING varchar array) c
+   FROM test_array
+   ORDER BY c ASC);
++----------------+
+| c              |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A13_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7][3]' RETURNING varchar array) c
+   FROM test_array
+   ORDER BY 1 DESC);
++----------------+
+| c              |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A14_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_null
+ORDER BY a_null ASC;
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
++--------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A14_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
++--------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A14_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A14_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A14_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_null c
+   FROM test_array
+   ORDER BY c ASC);
++--------------------+
+| c                  |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A14_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_null c
+   FROM test_array
+   ORDER BY 1 DESC);
++--------------------+
+| c                  |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A15_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[4]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[4]' RETURNING varchar array)
+ORDER BY json_value(a_nested, '$[4]' RETURNING varchar array) ASC;
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
++--------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A15_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[4]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
++--------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A15_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[4]' RETURNING varchar array) c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A15_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[4]' RETURNING varchar array) c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A15_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[4]' RETURNING varchar array) c
+   FROM test_array
+   ORDER BY c ASC);
++--------------------+
+| c                  |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A15_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[4]' RETURNING varchar array) c
+   FROM test_array
+   ORDER BY 1 DESC);
++--------------------+
+| c                  |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A16_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][4]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][4]' RETURNING varchar array)
+ORDER BY json_value(a_nested, '$[7][4]' RETURNING varchar array) ASC;
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
++--------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A16_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][4]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++--------------------+-----+
+| c                  | cnt |
++--------------------+-----+
+| [null, null, null] |   4 |
++--------------------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A16_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][4]' RETURNING varchar array) c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A16_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][4]' RETURNING varchar array) c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A16_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7][4]' RETURNING varchar array) c
+   FROM test_array
+   ORDER BY c ASC);
++--------------------+
+| c                  |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A16_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7][4]' RETURNING varchar array) c
+   FROM test_array
+   ORDER BY 1 DESC);
++--------------------+
+| c                  |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A17_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_empty
+ORDER BY a_empty ASC;
++----+-----+
+| c  | cnt |
++----+-----+
+| [] |   4 |
++----+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A17_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++----+-----+
+| c  | cnt |
++----+-----+
+| [] |   4 |
++----+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A17_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A17_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A17_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_empty c
+   FROM test_array
+   ORDER BY c ASC);
++----+
+| c  |
++----+
+| [] |
+| [] |
+| [] |
+| [] |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A17_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_empty c
+   FROM test_array
+   ORDER BY 1 DESC);
++----+
+| c  |
++----+
+| [] |
+| [] |
+| [] |
+| [] |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A18_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[5]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[5]' RETURNING varchar array)
+ORDER BY json_value(a_nested, '$[5]' RETURNING varchar array) ASC;
++----+-----+
+| c  | cnt |
++----+-----+
+| [] |   4 |
++----+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A18_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[5]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++----+-----+
+| c  | cnt |
++----+-----+
+| [] |   4 |
++----+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A18_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[5]' RETURNING varchar array) c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A18_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[5]' RETURNING varchar array) c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A18_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[5]' RETURNING varchar array) c
+   FROM test_array
+   ORDER BY c ASC);
++----+
+| c  |
++----+
+| [] |
+| [] |
+| [] |
+| [] |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A18_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[5]' RETURNING varchar array) c
+   FROM test_array
+   ORDER BY 1 DESC);
++----+
+| c  |
++----+
+| [] |
+| [] |
+| [] |
+| [] |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A19_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][5]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][5]' RETURNING varchar array)
+ORDER BY json_value(a_nested, '$[7][5]' RETURNING varchar array) ASC;
++----+-----+
+| c  | cnt |
++----+-----+
+| [] |   4 |
++----+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A19_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][5]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++----+-----+
+| c  | cnt |
++----+-----+
+| [] |   4 |
++----+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A19_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][5]' RETURNING varchar array) c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A19_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][5]' RETURNING varchar array) c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A19_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7][5]' RETURNING varchar array) c
+   FROM test_array
+   ORDER BY c ASC);
++----+
+| c  |
++----+
+| [] |
+| [] |
+| [] |
+| [] |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A19_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7][5]' RETURNING varchar array) c
+   FROM test_array
+   ORDER BY 1 DESC);
++----+
+| c  |
++----+
+| [] |
+| [] |
+| [] |
+| [] |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A20_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_mixed
+ORDER BY a_mixed ASC;
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A20_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A20_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A20_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A20_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_mixed c
+   FROM test_array
+   ORDER BY c ASC);
++--------------------------+
+| c                        |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A20_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_mixed c
+   FROM test_array
+   ORDER BY 1 DESC);
++--------------------------+
+| c                        |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A21_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[6]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[6]' RETURNING varchar array)
+ORDER BY json_value(a_nested, '$[6]' RETURNING varchar array) ASC;
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A21_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[6]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A21_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[6]' RETURNING varchar array) c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A21_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[6]' RETURNING varchar array) c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A21_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[6]' RETURNING varchar array) c
+   FROM test_array
+   ORDER BY c ASC);
++--------------------------+
+| c                        |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A21_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[6]' RETURNING varchar array) c
+   FROM test_array
+   ORDER BY 1 DESC);
++--------------------------+
+| c                        |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A22_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][6]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_value(a_nested, '$[7][6]' RETURNING varchar array)
+ORDER BY json_value(a_nested, '$[7][6]' RETURNING varchar array) ASC;
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [null, S1, 0.1, 1, true] |   2 |
+| [true, 1, 0.1, S1, null] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A22_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][6]' RETURNING varchar array) c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++--------------------------+-----+
+| c                        | cnt |
++--------------------------+-----+
+| [true, 1, 0.1, S1, null] |   2 |
+| [null, S1, 0.1, 1, true] |   2 |
++--------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A22_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][6]' RETURNING varchar array) c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A22_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][6]' RETURNING varchar array) c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A22_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7][6]' RETURNING varchar array) c
+   FROM test_array
+   ORDER BY c ASC);
++--------------------------+
+| c                        |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A22_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7][6]' RETURNING varchar array) c
+   FROM test_array
+   ORDER BY 1 DESC);
++--------------------------+
+| c                        |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A23_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested c,
+       count(*) cnt
+FROM test_array
+GROUP BY a_nested
+ORDER BY a_nested ASC;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| c                                                                                                                                                                                                                                                                                                                             | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A23_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| c                                                                                                                                                                                                                                                                                                                             | cnt |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |   2 |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |   2 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A23_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A23_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A23_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_nested c
+   FROM test_array
+   ORDER BY c ASC);
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                                                                                                                                             |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A23_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_nested c
+   FROM test_array
+   ORDER BY 1 DESC);
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                                                                                                                                             |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A24_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_nested, '$[7]') c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_query(a_nested, '$[7]')
+ORDER BY json_query(a_nested, '$[7]') ASC;
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| c                                                                                                                                                                                                                   | cnt |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]] |   2 |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]] |   2 |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A24_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_nested, '$[7]') c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| c                                                                                                                                                                                                                   | cnt |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]] |   2 |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A24_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_nested, '$[7]') c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A24_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_nested, '$[7]') c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A24_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_query(a_nested, '$[7]') c
+   FROM test_array
+   ORDER BY c ASC);
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                                   |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]] |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A24_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_query(a_nested, '$[7]') c
+   FROM test_array
+   ORDER BY 1 DESC);
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                                   |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]] |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A25_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_nested, '$[7][7]') c,
+       count(*) cnt
+FROM test_array
+GROUP BY json_query(a_nested, '$[7][7]')
+ORDER BY json_query(a_nested, '$[7][7]') ASC;
++-----------------------------------------------------------------------------------------------------------+-----+
+| c                                                                                                         | cnt |
++-----------------------------------------------------------------------------------------------------------+-----+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]] |   2 |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]] |   2 |
++-----------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A25_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_nested, '$[7][7]') c,
+       count(*) cnt
+FROM test_array
+GROUP BY 1
+ORDER BY 1 DESC;
++-----------------------------------------------------------------------------------------------------------+-----+
+| c                                                                                                         | cnt |
++-----------------------------------------------------------------------------------------------------------+-----+
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]] |   2 |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]] |   2 |
++-----------------------------------------------------------------------------------------------------------+-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A25_B5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_nested, '$[7][7]') c
+FROM test_array
+ORDER BY c ASC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A25_B6 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(a_nested, '$[7][7]') c
+FROM test_array
+ORDER BY 1 DESC;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A25_B7 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_query(a_nested, '$[7][7]') c
+   FROM test_array
+   ORDER BY c ASC);
++-----------------------------------------------------------------------------------------------------------+
+| c                                                                                                         |
++-----------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]] |
++-----------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_order_by TEST_ID: A25_B9 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_query(a_nested, '$[7][7]') c
+   FROM test_array
+   ORDER BY 1 DESC);
++-----------------------------------------------------------------------------------------------------------+
+| c                                                                                                         |
++-----------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]] |
++-----------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool c
+FROM test_array
+LIMIT 1;
++--------------+
+| c            |
++--------------+
+| [1, 0, null] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A1_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool c
+FROM test_array
+OFFSET 1;
++--------------+
+| c            |
++--------------+
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A1_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++--------------+
+| c            |
++--------------+
+| [1, 0, null] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int c
+FROM test_array
+LIMIT 1;
++--------------+
+| c            |
++--------------+
+| [1, 2, null] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A4_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int c
+FROM test_array
+OFFSET 1;
++--------------+
+| c            |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A4_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++--------------+
+| c            |
++--------------+
+| [1, 2, null] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[1]' RETURNING bigint array) c
+FROM test_array
+LIMIT 1;
++--------------+
+| c            |
++--------------+
+| [1, 2, null] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A5_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[1]' RETURNING bigint array) c
+FROM test_array
+OFFSET 1;
++--------------+
+| c            |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A5_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[1]' RETURNING bigint array) c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++--------------+
+| c            |
++--------------+
+| [1, 2, null] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][1]' RETURNING bigint array) c
+FROM test_array
+LIMIT 1;
++--------------+
+| c            |
++--------------+
+| [1, 2, null] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A6_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][1]' RETURNING bigint array) c
+FROM test_array
+OFFSET 1;
++--------------+
+| c            |
++--------------+
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A6_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][1]' RETURNING bigint array) c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++--------------+
+| c            |
++--------------+
+| [1, 2, null] |
++--------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float c
+FROM test_array
+LIMIT 1;
++------------------+
+| c                |
++------------------+
+| [0.1, 0.2, null] |
++------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A7_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float c
+FROM test_array
+OFFSET 1;
++------------------+
+| c                |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A7_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++------------------+
+| c                |
++------------------+
+| [0.1, 0.2, null] |
++------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A8_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[2]' RETURNING decimal array) c
+FROM test_array
+LIMIT 1;
++------------------+
+| c                |
++------------------+
+| [0.1, 0.2, null] |
++------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A8_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[2]' RETURNING decimal array) c
+FROM test_array
+OFFSET 1;
++------------------+
+| c                |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A8_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[2]' RETURNING decimal array) c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++------------------+
+| c                |
++------------------+
+| [0.1, 0.2, null] |
++------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A9_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][2]' RETURNING decimal array) c
+FROM test_array
+LIMIT 1;
++------------------+
+| c                |
++------------------+
+| [0.1, 0.2, null] |
++------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A9_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][2]' RETURNING decimal array) c
+FROM test_array
+OFFSET 1;
++------------------+
+| c                |
++------------------+
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A9_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][2]' RETURNING decimal array) c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++------------------+
+| c                |
++------------------+
+| [0.1, 0.2, null] |
++------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A10_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str c
+FROM test_array
+LIMIT 1;
++----------------+
+| c              |
++----------------+
+| [S1, S2, null] |
++----------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A10_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str c
+FROM test_array
+OFFSET 1;
++----------------+
+| c              |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A10_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++----------------+
+| c              |
++----------------+
+| [S1, S2, null] |
++----------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A11_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[3]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1;
++----------------+
+| c              |
++----------------+
+| [S1, S2, null] |
++----------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A11_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[3]' RETURNING varchar array) c
+FROM test_array
+OFFSET 1;
++----------------+
+| c              |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A11_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[3]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++----------------+
+| c              |
++----------------+
+| [S1, S2, null] |
++----------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A12_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][3]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1;
++----------------+
+| c              |
++----------------+
+| [S1, S2, null] |
++----------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A12_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][3]' RETURNING varchar array) c
+FROM test_array
+OFFSET 1;
++----------------+
+| c              |
++----------------+
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A12_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][3]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++----------------+
+| c              |
++----------------+
+| [S1, S2, null] |
++----------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A13_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null c
+FROM test_array
+LIMIT 1;
++--------------------+
+| c                  |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A13_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null c
+FROM test_array
+OFFSET 1;
++--------------------+
+| c                  |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A13_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++--------------------+
+| c                  |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A14_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[4]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1;
++--------------------+
+| c                  |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A14_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[4]' RETURNING varchar array) c
+FROM test_array
+OFFSET 1;
++--------------------+
+| c                  |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A14_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[4]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++--------------------+
+| c                  |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A15_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][4]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1;
++--------------------+
+| c                  |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A15_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][4]' RETURNING varchar array) c
+FROM test_array
+OFFSET 1;
++--------------------+
+| c                  |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A15_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][4]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++--------------------+
+| c                  |
++--------------------+
+| [null, null, null] |
++--------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A16_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty c
+FROM test_array
+LIMIT 1;
++----+
+| c  |
++----+
+| [] |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A16_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty c
+FROM test_array
+OFFSET 1;
++----+
+| c  |
++----+
+| [] |
+| [] |
+| [] |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A16_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++----+
+| c  |
++----+
+| [] |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A17_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[5]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1;
++----+
+| c  |
++----+
+| [] |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A17_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[5]' RETURNING varchar array) c
+FROM test_array
+OFFSET 1;
++----+
+| c  |
++----+
+| [] |
+| [] |
+| [] |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A17_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[5]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++----+
+| c  |
++----+
+| [] |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A18_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][5]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1;
++----+
+| c  |
++----+
+| [] |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A18_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][5]' RETURNING varchar array) c
+FROM test_array
+OFFSET 1;
++----+
+| c  |
++----+
+| [] |
+| [] |
+| [] |
++----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A18_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][5]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++----+
+| c  |
++----+
+| [] |
++----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A19_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed c
+FROM test_array
+LIMIT 1;
++--------------------------+
+| c                        |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A19_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed c
+FROM test_array
+OFFSET 1;
++--------------------------+
+| c                        |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A19_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++--------------------------+
+| c                        |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A20_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[6]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1;
++--------------------------+
+| c                        |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A20_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[6]' RETURNING varchar array) c
+FROM test_array
+OFFSET 1;
++--------------------------+
+| c                        |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A20_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[6]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++--------------------------+
+| c                        |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A21_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][6]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1;
++--------------------------+
+| c                        |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A21_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][6]' RETURNING varchar array) c
+FROM test_array
+OFFSET 1;
++--------------------------+
+| c                        |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A21_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][6]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++--------------------------+
+| c                        |
++--------------------------+
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A22_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested c
+FROM test_array
+LIMIT 1;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                                                                                                                                             |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A22_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested c
+FROM test_array
+OFFSET 1;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                                                                                                                                             |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A22_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                                                                                                                                             |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A23_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A23_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7]' RETURNING varchar array) c
+FROM test_array
+OFFSET 1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A23_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A24_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][7]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A24_B3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][7]' RETURNING varchar array) c
+FROM test_array
+OFFSET 1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_limit_offset TEST_ID: A24_B5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(a_nested, '$[7][7]' RETURNING varchar array) c
+FROM test_array
+LIMIT 1
+OFFSET 1;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_bool
+FROM test_array t1
+INNER JOIN test_array t2 ON t1.a_bool=t2.a_bool;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array t1
+   INNER JOIN test_array t2 ON t1.a_bool=t2.a_bool);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B1_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_bool
+FROM t1
+INNER JOIN test_array t2 ON t1.a_bool=t2.a_bool;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_int
+FROM test_array t1
+INNER JOIN test_array t2 ON t1.a_int=t2.a_int;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array t1
+   INNER JOIN test_array t2 ON t1.a_int=t2.a_int);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B2_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_int
+FROM t1
+INNER JOIN test_array t2 ON t1.a_int=t2.a_int;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B3_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_float
+FROM test_array t1
+INNER JOIN test_array t2 ON t1.a_float=t2.a_float;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B3_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array t1
+   INNER JOIN test_array t2 ON t1.a_float=t2.a_float);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B3_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_float
+FROM t1
+INNER JOIN test_array t2 ON t1.a_float=t2.a_float;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B4_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_str
+FROM test_array t1
+INNER JOIN test_array t2 ON t1.a_str=t2.a_str;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B4_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array t1
+   INNER JOIN test_array t2 ON t1.a_str=t2.a_str);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B4_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_str
+FROM t1
+INNER JOIN test_array t2 ON t1.a_str=t2.a_str;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B5_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_null
+FROM test_array t1
+INNER JOIN test_array t2 ON t1.a_null=t2.a_null;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B5_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null
+FROM
+  (SELECT *
+   FROM test_array t1
+   INNER JOIN test_array t2 ON t1.a_null=t2.a_null);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B5_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_null
+FROM t1
+INNER JOIN test_array t2 ON t1.a_null=t2.a_null;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B6_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_empty
+FROM test_array t1
+INNER JOIN test_array t2 ON t1.a_empty=t2.a_empty;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B6_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty
+FROM
+  (SELECT *
+   FROM test_array t1
+   INNER JOIN test_array t2 ON t1.a_empty=t2.a_empty);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B6_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_empty
+FROM t1
+INNER JOIN test_array t2 ON t1.a_empty=t2.a_empty;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B7_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_mixed
+FROM test_array t1
+INNER JOIN test_array t2 ON t1.a_mixed=t2.a_mixed;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B7_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array t1
+   INNER JOIN test_array t2 ON t1.a_mixed=t2.a_mixed);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B7_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_mixed
+FROM t1
+INNER JOIN test_array t2 ON t1.a_mixed=t2.a_mixed;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B8_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_nested
+FROM test_array t1
+INNER JOIN test_array t2 ON t1.a_nested=t2.a_nested;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B8_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array t1
+   INNER JOIN test_array t2 ON t1.a_nested=t2.a_nested);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A1_B8_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_nested
+FROM t1
+INNER JOIN test_array t2 ON t1.a_nested=t2.a_nested;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_bool
+FROM test_array t1
+JOIN test_array t2 ON t1.a_bool=t2.a_bool;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array t1
+   JOIN test_array t2 ON t1.a_bool=t2.a_bool);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B1_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_bool
+FROM t1
+JOIN test_array t2 ON t1.a_bool=t2.a_bool;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_int
+FROM test_array t1
+JOIN test_array t2 ON t1.a_int=t2.a_int;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array t1
+   JOIN test_array t2 ON t1.a_int=t2.a_int);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B2_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_int
+FROM t1
+JOIN test_array t2 ON t1.a_int=t2.a_int;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B3_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_float
+FROM test_array t1
+JOIN test_array t2 ON t1.a_float=t2.a_float;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B3_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array t1
+   JOIN test_array t2 ON t1.a_float=t2.a_float);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B3_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_float
+FROM t1
+JOIN test_array t2 ON t1.a_float=t2.a_float;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B4_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_str
+FROM test_array t1
+JOIN test_array t2 ON t1.a_str=t2.a_str;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B4_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array t1
+   JOIN test_array t2 ON t1.a_str=t2.a_str);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B4_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_str
+FROM t1
+JOIN test_array t2 ON t1.a_str=t2.a_str;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B5_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_null
+FROM test_array t1
+JOIN test_array t2 ON t1.a_null=t2.a_null;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B5_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null
+FROM
+  (SELECT *
+   FROM test_array t1
+   JOIN test_array t2 ON t1.a_null=t2.a_null);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B5_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_null
+FROM t1
+JOIN test_array t2 ON t1.a_null=t2.a_null;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B6_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_empty
+FROM test_array t1
+JOIN test_array t2 ON t1.a_empty=t2.a_empty;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B6_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty
+FROM
+  (SELECT *
+   FROM test_array t1
+   JOIN test_array t2 ON t1.a_empty=t2.a_empty);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B6_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_empty
+FROM t1
+JOIN test_array t2 ON t1.a_empty=t2.a_empty;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B7_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_mixed
+FROM test_array t1
+JOIN test_array t2 ON t1.a_mixed=t2.a_mixed;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B7_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array t1
+   JOIN test_array t2 ON t1.a_mixed=t2.a_mixed);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B7_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_mixed
+FROM t1
+JOIN test_array t2 ON t1.a_mixed=t2.a_mixed;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B8_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_nested
+FROM test_array t1
+JOIN test_array t2 ON t1.a_nested=t2.a_nested;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B8_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array t1
+   JOIN test_array t2 ON t1.a_nested=t2.a_nested);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A2_B8_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_nested
+FROM t1
+JOIN test_array t2 ON t1.a_nested=t2.a_nested;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_bool
+FROM test_array t1
+LEFT JOIN test_array t2 ON t1.a_bool=t2.a_bool;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array t1
+   LEFT JOIN test_array t2 ON t1.a_bool=t2.a_bool);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B1_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_bool
+FROM t1
+LEFT JOIN test_array t2 ON t1.a_bool=t2.a_bool;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_int
+FROM test_array t1
+LEFT JOIN test_array t2 ON t1.a_int=t2.a_int;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array t1
+   LEFT JOIN test_array t2 ON t1.a_int=t2.a_int);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B2_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_int
+FROM t1
+LEFT JOIN test_array t2 ON t1.a_int=t2.a_int;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B3_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_float
+FROM test_array t1
+LEFT JOIN test_array t2 ON t1.a_float=t2.a_float;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B3_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array t1
+   LEFT JOIN test_array t2 ON t1.a_float=t2.a_float);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B3_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_float
+FROM t1
+LEFT JOIN test_array t2 ON t1.a_float=t2.a_float;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B4_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_str
+FROM test_array t1
+LEFT JOIN test_array t2 ON t1.a_str=t2.a_str;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B4_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array t1
+   LEFT JOIN test_array t2 ON t1.a_str=t2.a_str);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B4_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_str
+FROM t1
+LEFT JOIN test_array t2 ON t1.a_str=t2.a_str;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B5_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_null
+FROM test_array t1
+LEFT JOIN test_array t2 ON t1.a_null=t2.a_null;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B5_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null
+FROM
+  (SELECT *
+   FROM test_array t1
+   LEFT JOIN test_array t2 ON t1.a_null=t2.a_null);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B5_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_null
+FROM t1
+LEFT JOIN test_array t2 ON t1.a_null=t2.a_null;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B6_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_empty
+FROM test_array t1
+LEFT JOIN test_array t2 ON t1.a_empty=t2.a_empty;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B6_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty
+FROM
+  (SELECT *
+   FROM test_array t1
+   LEFT JOIN test_array t2 ON t1.a_empty=t2.a_empty);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B6_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_empty
+FROM t1
+LEFT JOIN test_array t2 ON t1.a_empty=t2.a_empty;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B7_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_mixed
+FROM test_array t1
+LEFT JOIN test_array t2 ON t1.a_mixed=t2.a_mixed;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B7_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array t1
+   LEFT JOIN test_array t2 ON t1.a_mixed=t2.a_mixed);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B7_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_mixed
+FROM t1
+LEFT JOIN test_array t2 ON t1.a_mixed=t2.a_mixed;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B8_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_nested
+FROM test_array t1
+LEFT JOIN test_array t2 ON t1.a_nested=t2.a_nested;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B8_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array t1
+   LEFT JOIN test_array t2 ON t1.a_nested=t2.a_nested);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A3_B8_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_nested
+FROM t1
+LEFT JOIN test_array t2 ON t1.a_nested=t2.a_nested;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_bool
+FROM test_array t1
+RIGHT JOIN test_array t2 ON t1.a_bool=t2.a_bool;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array t1
+   RIGHT JOIN test_array t2 ON t1.a_bool=t2.a_bool);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B1_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_bool
+FROM t1
+RIGHT JOIN test_array t2 ON t1.a_bool=t2.a_bool;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_int
+FROM test_array t1
+RIGHT JOIN test_array t2 ON t1.a_int=t2.a_int;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array t1
+   RIGHT JOIN test_array t2 ON t1.a_int=t2.a_int);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B2_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_int
+FROM t1
+RIGHT JOIN test_array t2 ON t1.a_int=t2.a_int;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B3_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_float
+FROM test_array t1
+RIGHT JOIN test_array t2 ON t1.a_float=t2.a_float;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B3_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array t1
+   RIGHT JOIN test_array t2 ON t1.a_float=t2.a_float);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B3_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_float
+FROM t1
+RIGHT JOIN test_array t2 ON t1.a_float=t2.a_float;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B4_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_str
+FROM test_array t1
+RIGHT JOIN test_array t2 ON t1.a_str=t2.a_str;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B4_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array t1
+   RIGHT JOIN test_array t2 ON t1.a_str=t2.a_str);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B4_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_str
+FROM t1
+RIGHT JOIN test_array t2 ON t1.a_str=t2.a_str;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B5_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_null
+FROM test_array t1
+RIGHT JOIN test_array t2 ON t1.a_null=t2.a_null;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B5_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null
+FROM
+  (SELECT *
+   FROM test_array t1
+   RIGHT JOIN test_array t2 ON t1.a_null=t2.a_null);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B5_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_null
+FROM t1
+RIGHT JOIN test_array t2 ON t1.a_null=t2.a_null;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B6_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_empty
+FROM test_array t1
+RIGHT JOIN test_array t2 ON t1.a_empty=t2.a_empty;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B6_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty
+FROM
+  (SELECT *
+   FROM test_array t1
+   RIGHT JOIN test_array t2 ON t1.a_empty=t2.a_empty);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B6_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_empty
+FROM t1
+RIGHT JOIN test_array t2 ON t1.a_empty=t2.a_empty;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B7_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_mixed
+FROM test_array t1
+RIGHT JOIN test_array t2 ON t1.a_mixed=t2.a_mixed;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B7_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array t1
+   RIGHT JOIN test_array t2 ON t1.a_mixed=t2.a_mixed);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B7_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_mixed
+FROM t1
+RIGHT JOIN test_array t2 ON t1.a_mixed=t2.a_mixed;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B8_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_nested
+FROM test_array t1
+RIGHT JOIN test_array t2 ON t1.a_nested=t2.a_nested;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B8_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array t1
+   RIGHT JOIN test_array t2 ON t1.a_nested=t2.a_nested);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A4_B8_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_nested
+FROM t1
+RIGHT JOIN test_array t2 ON t1.a_nested=t2.a_nested;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_bool
+FROM test_array t1
+FULL JOIN test_array t2 ON t1.a_bool=t2.a_bool;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array t1
+   FULL JOIN test_array t2 ON t1.a_bool=t2.a_bool);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B1_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_bool
+FROM t1
+FULL JOIN test_array t2 ON t1.a_bool=t2.a_bool;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_int
+FROM test_array t1
+FULL JOIN test_array t2 ON t1.a_int=t2.a_int;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array t1
+   FULL JOIN test_array t2 ON t1.a_int=t2.a_int);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B2_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_int
+FROM t1
+FULL JOIN test_array t2 ON t1.a_int=t2.a_int;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B3_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_float
+FROM test_array t1
+FULL JOIN test_array t2 ON t1.a_float=t2.a_float;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B3_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array t1
+   FULL JOIN test_array t2 ON t1.a_float=t2.a_float);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B3_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_float
+FROM t1
+FULL JOIN test_array t2 ON t1.a_float=t2.a_float;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B4_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_str
+FROM test_array t1
+FULL JOIN test_array t2 ON t1.a_str=t2.a_str;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B4_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array t1
+   FULL JOIN test_array t2 ON t1.a_str=t2.a_str);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B4_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_str
+FROM t1
+FULL JOIN test_array t2 ON t1.a_str=t2.a_str;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B5_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_null
+FROM test_array t1
+FULL JOIN test_array t2 ON t1.a_null=t2.a_null;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B5_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null
+FROM
+  (SELECT *
+   FROM test_array t1
+   FULL JOIN test_array t2 ON t1.a_null=t2.a_null);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B5_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_null
+FROM t1
+FULL JOIN test_array t2 ON t1.a_null=t2.a_null;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B6_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_empty
+FROM test_array t1
+FULL JOIN test_array t2 ON t1.a_empty=t2.a_empty;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B6_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty
+FROM
+  (SELECT *
+   FROM test_array t1
+   FULL JOIN test_array t2 ON t1.a_empty=t2.a_empty);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B6_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_empty
+FROM t1
+FULL JOIN test_array t2 ON t1.a_empty=t2.a_empty;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B7_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_mixed
+FROM test_array t1
+FULL JOIN test_array t2 ON t1.a_mixed=t2.a_mixed;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B7_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array t1
+   FULL JOIN test_array t2 ON t1.a_mixed=t2.a_mixed);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B7_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_mixed
+FROM t1
+FULL JOIN test_array t2 ON t1.a_mixed=t2.a_mixed;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B8_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_nested
+FROM test_array t1
+FULL JOIN test_array t2 ON t1.a_nested=t2.a_nested;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B8_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array t1
+   FULL JOIN test_array t2 ON t1.a_nested=t2.a_nested);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A5_B8_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_nested
+FROM t1
+FULL JOIN test_array t2 ON t1.a_nested=t2.a_nested;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_bool
+FROM test_array t1,
+     test_array t2
+WHERE t1.a_bool=t2.a_bool;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array t1,
+        test_array t2
+   WHERE t1.a_bool=t2.a_bool);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B1_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_bool
+FROM t1,
+     test_array t2
+WHERE t1.a_bool=t2.a_bool;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_int
+FROM test_array t1,
+     test_array t2
+WHERE t1.a_int=t2.a_int;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array t1,
+        test_array t2
+   WHERE t1.a_int=t2.a_int);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B2_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_int
+FROM t1,
+     test_array t2
+WHERE t1.a_int=t2.a_int;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B3_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_float
+FROM test_array t1,
+     test_array t2
+WHERE t1.a_float=t2.a_float;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B3_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array t1,
+        test_array t2
+   WHERE t1.a_float=t2.a_float);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B3_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_float
+FROM t1,
+     test_array t2
+WHERE t1.a_float=t2.a_float;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B4_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_str
+FROM test_array t1,
+     test_array t2
+WHERE t1.a_str=t2.a_str;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B4_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array t1,
+        test_array t2
+   WHERE t1.a_str=t2.a_str);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B4_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_str
+FROM t1,
+     test_array t2
+WHERE t1.a_str=t2.a_str;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B5_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_null
+FROM test_array t1,
+     test_array t2
+WHERE t1.a_null=t2.a_null;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B5_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null
+FROM
+  (SELECT *
+   FROM test_array t1,
+        test_array t2
+   WHERE t1.a_null=t2.a_null);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B5_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_null
+FROM t1,
+     test_array t2
+WHERE t1.a_null=t2.a_null;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B6_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_empty
+FROM test_array t1,
+     test_array t2
+WHERE t1.a_empty=t2.a_empty;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B6_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty
+FROM
+  (SELECT *
+   FROM test_array t1,
+        test_array t2
+   WHERE t1.a_empty=t2.a_empty);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B6_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_empty
+FROM t1,
+     test_array t2
+WHERE t1.a_empty=t2.a_empty;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B7_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_mixed
+FROM test_array t1,
+     test_array t2
+WHERE t1.a_mixed=t2.a_mixed;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B7_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array t1,
+        test_array t2
+   WHERE t1.a_mixed=t2.a_mixed);
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B7_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_mixed
+FROM t1,
+     test_array t2
+WHERE t1.a_mixed=t2.a_mixed;
+not support
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B8_C1 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_nested
+FROM test_array t1,
+     test_array t2
+WHERE t1.a_nested=t2.a_nested;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B8_C3 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array t1,
+        test_array t2
+   WHERE t1.a_nested=t2.a_nested);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A6_B8_C5 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_nested
+FROM t1,
+     test_array t2
+WHERE t1.a_nested=t2.a_nested;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_bool
+FROM test_array t1
+CROSS JOIN test_array t2;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_bool
+FROM
+  (SELECT *
+   FROM test_array t1
+   CROSS JOIN test_array t2);
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B1_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_bool
+FROM t1
+CROSS JOIN test_array t2;
++--------------+
+| a_bool       |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_int
+FROM test_array t1
+CROSS JOIN test_array t2;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_int
+FROM
+  (SELECT *
+   FROM test_array t1
+   CROSS JOIN test_array t2);
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B2_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_int
+FROM t1
+CROSS JOIN test_array t2;
++--------------+
+| a_int        |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B3_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_float
+FROM test_array t1
+CROSS JOIN test_array t2;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B3_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_float
+FROM
+  (SELECT *
+   FROM test_array t1
+   CROSS JOIN test_array t2);
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B3_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_float
+FROM t1
+CROSS JOIN test_array t2;
++------------------+
+| a_float          |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B4_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_str
+FROM test_array t1
+CROSS JOIN test_array t2;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B4_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_str
+FROM
+  (SELECT *
+   FROM test_array t1
+   CROSS JOIN test_array t2);
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B4_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_str
+FROM t1
+CROSS JOIN test_array t2;
++----------------+
+| a_str          |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B5_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_null
+FROM test_array t1
+CROSS JOIN test_array t2;
++--------------------+
+| a_null             |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B5_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_null
+FROM
+  (SELECT *
+   FROM test_array t1
+   CROSS JOIN test_array t2);
++--------------------+
+| a_null             |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B5_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_null
+FROM t1
+CROSS JOIN test_array t2;
++--------------------+
+| a_null             |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B6_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_empty
+FROM test_array t1
+CROSS JOIN test_array t2;
++---------+
+| a_empty |
++---------+
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
++---------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B6_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_empty
+FROM
+  (SELECT *
+   FROM test_array t1
+   CROSS JOIN test_array t2);
++---------+
+| a_empty |
++---------+
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
++---------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B6_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_empty
+FROM t1
+CROSS JOIN test_array t2;
++---------+
+| a_empty |
++---------+
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
+| []      |
++---------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B7_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_mixed
+FROM test_array t1
+CROSS JOIN test_array t2;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B7_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_mixed
+FROM
+  (SELECT *
+   FROM test_array t1
+   CROSS JOIN test_array t2);
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B7_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_mixed
+FROM t1
+CROSS JOIN test_array t2;
++--------------------------+
+| a_mixed                  |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B8_C1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT t1.a_nested
+FROM test_array t1
+CROSS JOIN test_array t2;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B8_C3 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT a_nested
+FROM
+  (SELECT *
+   FROM test_array t1
+   CROSS JOIN test_array t2);
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_join TEST_ID: A7_B8_C5 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+WITH t1 AS
+  (SELECT *
+   FROM test_array)
+SELECT t1.a_nested
+FROM t1
+CROSS JOIN test_array t2;
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| a_nested                                                                                                                                                                                                                                                                                                                      |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(16 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A1_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_bool c
+   FROM test_array
+   UNION ALL SELECT a_bool c
+   FROM test_array);
++--------------+
+| c            |
++--------------+
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [1, 0, null] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
+| [null, 0, 1] |
++--------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A4_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_int c
+   FROM test_array
+   UNION ALL SELECT a_int c
+   FROM test_array);
++--------------+
+| c            |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A5_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[1]' RETURNING bigint array) c
+   FROM test_array
+   UNION ALL SELECT json_value(a_nested, '$[1]' RETURNING bigint array) c
+   FROM test_array);
++--------------+
+| c            |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A6_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7][1]' RETURNING bigint array) c
+   FROM test_array
+   UNION ALL SELECT json_value(a_nested, '$[7][1]' RETURNING bigint array) c
+   FROM test_array);
++--------------+
+| c            |
++--------------+
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [1, 2, null] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
+| [null, 2, 1] |
++--------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A7_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_float c
+   FROM test_array
+   UNION ALL SELECT a_float c
+   FROM test_array);
++------------------+
+| c                |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A8_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[2]' RETURNING decimal array) c
+   FROM test_array
+   UNION ALL SELECT json_value(a_nested, '$[2]' RETURNING decimal array) c
+   FROM test_array);
++------------------+
+| c                |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A9_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7][2]' RETURNING decimal array) c
+   FROM test_array
+   UNION ALL SELECT json_value(a_nested, '$[7][2]' RETURNING decimal array) c
+   FROM test_array);
++------------------+
+| c                |
++------------------+
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [0.1, 0.2, null] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
+| [null, 0.2, 0.1] |
++------------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A10_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_str c
+   FROM test_array
+   UNION ALL SELECT a_str c
+   FROM test_array);
++----------------+
+| c              |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A11_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[3]' RETURNING varchar array) c
+   FROM test_array
+   UNION ALL SELECT json_value(a_nested, '$[3]' RETURNING varchar array) c
+   FROM test_array);
++----------------+
+| c              |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A12_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7][3]' RETURNING varchar array) c
+   FROM test_array
+   UNION ALL SELECT json_value(a_nested, '$[7][3]' RETURNING varchar array) c
+   FROM test_array);
++----------------+
+| c              |
++----------------+
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [S1, S2, null] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
+| [null, S2, S1] |
++----------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A13_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_null c
+   FROM test_array
+   UNION ALL SELECT a_null c
+   FROM test_array);
++--------------------+
+| c                  |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A14_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[4]' RETURNING varchar array) c
+   FROM test_array
+   UNION ALL SELECT json_value(a_nested, '$[4]' RETURNING varchar array) c
+   FROM test_array);
++--------------------+
+| c                  |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A15_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7][4]' RETURNING varchar array) c
+   FROM test_array
+   UNION ALL SELECT json_value(a_nested, '$[7][4]' RETURNING varchar array) c
+   FROM test_array);
++--------------------+
+| c                  |
++--------------------+
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
+| [null, null, null] |
++--------------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A16_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_empty c
+   FROM test_array
+   UNION ALL SELECT a_empty c
+   FROM test_array);
++----+
+| c  |
++----+
+| [] |
+| [] |
+| [] |
+| [] |
+| [] |
+| [] |
+| [] |
+| [] |
++----+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A17_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[5]' RETURNING varchar array) c
+   FROM test_array
+   UNION ALL SELECT json_value(a_nested, '$[5]' RETURNING varchar array) c
+   FROM test_array);
++----+
+| c  |
++----+
+| [] |
+| [] |
+| [] |
+| [] |
+| [] |
+| [] |
+| [] |
+| [] |
++----+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A18_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7][5]' RETURNING varchar array) c
+   FROM test_array
+   UNION ALL SELECT json_value(a_nested, '$[7][5]' RETURNING varchar array) c
+   FROM test_array);
++----+
+| c  |
++----+
+| [] |
+| [] |
+| [] |
+| [] |
+| [] |
+| [] |
+| [] |
+| [] |
++----+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A19_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_mixed c
+   FROM test_array
+   UNION ALL SELECT a_mixed c
+   FROM test_array);
++--------------------------+
+| c                        |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A20_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[6]' RETURNING varchar array) c
+   FROM test_array
+   UNION ALL SELECT json_value(a_nested, '$[6]' RETURNING varchar array) c
+   FROM test_array);
++--------------------------+
+| c                        |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A21_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7][6]' RETURNING varchar array) c
+   FROM test_array
+   UNION ALL SELECT json_value(a_nested, '$[7][6]' RETURNING varchar array) c
+   FROM test_array);
++--------------------------+
+| c                        |
++--------------------------+
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [null, S1, 0.1, 1, true] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
+| [true, 1, 0.1, S1, null] |
++--------------------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A22_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT a_nested c
+   FROM test_array
+   UNION ALL SELECT a_nested c
+   FROM test_array);
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                                                                                                                                             |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,"S2","S1"],[null,null,null],[],[null,"S1",0.1,1,true]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
+| [[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null],[[true,false,null],[1,2,null],[0.1,0.2,null],["S1","S2",null],[null,null,null],[],[true,1,0.1,"S1",null]]]] |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A23_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7]' RETURNING varchar array) c
+   FROM test_array
+   UNION ALL SELECT json_value(a_nested, '$[7]' RETURNING varchar array) c
+   FROM test_array);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_union_all TEST_ID: A24_B1 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT c
+FROM
+  (SELECT json_value(a_nested, '$[7][7]' RETURNING varchar array) c
+   FROM test_array
+   UNION ALL SELECT json_value(a_nested, '$[7][7]' RETURNING varchar array) c
+   FROM test_array);
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# Total query count 3400 Positive tests: 2939 Negative tests: 461
+#-------------------------------------------------------------------------
diff --git a/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaJsonCols_funcs_and_sql.iq b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaJsonCols_funcs_and_sql.iq
new file mode 100644
index 000000000000..7c532778b41d
--- /dev/null
+++ b/quidem-ut/src/test/quidem/org.apache.druid.quidem.QTest/qaJsonCols_funcs_and_sql.iq
@@ -0,0 +1,15280 @@
+!set useApproximateCountDistinct false
+!use druidtest://?componentSupplier=StandardComponentSupplier&datasets=sql/src/test/quidem/qatests/qaJsonCols/funcs_and_sql
+!set outputformat mysql
+SELECT count(*) cnt
+FROM test_json_cols;
++-----+
+| cnt |
++-----+
+|   4 |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A001 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 = c1) c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A002 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 = c1;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A003 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 <> c1) c
+FROM test_json_cols;
++-------+
+| c     |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A004 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 <> c1;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A005 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 > c2) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A006 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 > c2;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A007 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 >= c2) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A008 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 >= c2;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A009 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 < c2) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A010 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 < c2;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A011 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 <= c2) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A012 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 <= c2;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A013 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 BETWEEN c1 AND c2) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A014 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 BETWEEN c1 AND c2;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A015 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 NOT BETWEEN c1 AND c2) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A016 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 NOT BETWEEN c1 AND c2;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A017 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 like c2) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A018 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 like c2;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A019 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 not like c2) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A020 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 not like c2;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A021 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 IS NULL) c
+FROM test_json_cols;
++-------+
+| c     |
++-------+
+| false |
+| false |
+| false |
+| false |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A022 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A023 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 IS NOT NULL) c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| true |
+| true |
+| true |
+| true |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A024 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A025 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 IS TRUE) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A026 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 IS TRUE;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A027 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 IS NOT TRUE) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A028 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 IS NOT TRUE;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A029 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 IS FALSE) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A030 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 IS FALSE;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A031 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 IS NOT FALSE) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A032 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 IS NOT FALSE;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A033 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 IN (json_object(KEY 'a1' VALUE 'A', KEY 'a2' VALUE 1))) c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A034 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 IN (json_object(KEY 'a1' VALUE 'A', KEY 'a2' VALUE 1));
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A035 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 NOT IN (json_object(KEY 'a1' VALUE 'A', KEY 'a2' VALUE 1))) c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A036 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 NOT IN (json_object(KEY 'a1' VALUE 'A', KEY 'a2' VALUE 1));
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A037 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 IN
+          (SELECT c1
+           FROM test_json_cols)) c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A038 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 IN
+    (SELECT c1
+     FROM test_json_cols);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A039 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1 NOT IN
+          (SELECT c1
+           FROM test_json_cols)) c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A040 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 NOT IN
+    (SELECT c1
+     FROM test_json_cols);
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A041 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1
+        AND c2) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A042 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1
+  AND c2;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A043 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (c1
+        OR c2) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A044 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1
+  OR c2;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A045 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT (NOT c1) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_comp_ops TEST_ID: A046 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE NOT c1;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_sql TEST_ID: A001 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_sql TEST_ID: A002 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE c1 IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_sql TEST_ID: A003 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT c1
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_sql TEST_ID: A004 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT ALL c1
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_sql TEST_ID: A005 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT *
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_sql TEST_ID: A006 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT ALL *
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_sql TEST_ID: A007 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c1) c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_sql TEST_ID: A008 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT DISTINCT c1
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_sql TEST_ID: A009 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c1) c
+FROM test_json_cols
+GROUP BY c1;
++---+
+| c |
++---+
+| 2 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_sql TEST_ID: A010 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(c1) c
+FROM test_json_cols
+GROUP BY c1
+HAVING count(c1) >= 2;
++---+
+| c |
++---+
+| 2 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_sql TEST_ID: A011 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT *
+FROM test_json_cols
+WHERE c1 = c2;
++--------+-------+-----------+-------------+--------+--------+-------------+---------------+--------------------+----------------------+----+----+-------+---------+--------+------------+--------------+---------+---------+-------------+---------------+--------+------------+--------------+---------+---------+-------+-----+
+| __time | s_str | s_num_int | s_num_float | s_bool | s_null | c_empty_obj | c_empty_array | c_empty_obj_nested | c_empty_array_nested | c1 | c2 | t_obj | t_array | t_str1 | t_num_int1 | t_num_float1 | t_bool1 | t_null1 | t_empty_obj | t_empty_array | t_str2 | t_num_int2 | t_num_float2 | t_bool2 | t_null2 | t_new | cnt |
++--------+-------+-----------+-------------+--------+--------+-------------+---------------+--------------------+----------------------+----+----+-------+---------+--------+------------+--------------+---------+---------+-------------+---------------+--------+------------+--------------+---------+---------+-------+-----+
++--------+-------+-----------+-------------+--------+--------+-------------+---------------+--------------------+----------------------+----+----+-------+---------+--------+------------+--------------+---------+---------+-------------+---------------+--------+------------+--------------+---------+---------+-------+-----+
+(0 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_sql TEST_ID: A012 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT *
+FROM test_json_cols t1
+INNER JOIN test_json_cols t2 ON t1.c1=t2.c1;
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_sql TEST_ID: A013 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT *
+FROM test_json_cols t1
+LEFT JOIN test_json_cols t2 ON t1.c1=t2.c1;
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_sql TEST_ID: A014 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT *
+FROM test_json_cols t1,
+     test_json_cols t2
+WHERE t1.c1=t2.c1;
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_sql TEST_ID: A015 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT *
+FROM test_json_cols
+ORDER BY __time;
++-------------------------+-------+-----------+-------------+--------+--------+-------------+---------------+-----------------------------+----------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------+---------+--------+------------+--------------+---------+---------+-------------+---------------+--------+------------+--------------+---------+---------+-------+-----+
+| __time                  | s_str | s_num_int | s_num_float | s_bool | s_null | c_empty_obj | c_empty_array | c_empty_obj_nested          | c_empty_array_nested | c1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | c2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | t_obj | t_array | t_str1 | t_num_int1 | t_num_float1 | t_bool1 | t_null1 | t_empty_obj | t_empty_array | t_str2 | t_num_int2 | t_num_float2 | t_bool2 | t_null2 | t_new | cnt |
++-------------------------+-------+-----------+-------------+--------+--------+-------------+---------------+-----------------------------+----------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------+---------+--------+------------+--------------+---------+---------+-------------+---------------+--------+------------+--------------+---------+---------+-------+-----+
+| 2022-01-01 00:00:00.000 | A     |         1 |         0.1 |      1 |        | {}          | []            | {"o1":{},"o2":[],"o3":null} | [{},[],null]         | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
+| 2022-01-01 00:00:00.000 | A     |         1 |         0.1 |      1 |        | {}          | []            | {"o1":{},"o2":[],"o3":null} | [{},[],null]         | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
+| 2022-02-01 00:00:00.000 |       |           |             |        |        |             |               |                             |                      | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
+| 2022-02-01 00:00:00.000 |       |           |             |        |        |             |               |                             |                      | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
++-------------------------+-------+-----------+-------------+--------+--------+-------------+---------------+-----------------------------+----------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------+---------+--------+------------+--------------+---------+---------+-------------+---------------+--------+------------+--------------+---------+---------+-------+-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_sql TEST_ID: A016 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT *
+FROM test_json_cols
+LIMIT 1;
++-------------------------+-------+-----------+-------------+--------+--------+-------------+---------------+-----------------------------+----------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------+---------+--------+------------+--------------+---------+---------+-------------+---------------+--------+------------+--------------+---------+---------+-------+-----+
+| __time                  | s_str | s_num_int | s_num_float | s_bool | s_null | c_empty_obj | c_empty_array | c_empty_obj_nested          | c_empty_array_nested | c1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | c2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | t_obj | t_array | t_str1 | t_num_int1 | t_num_float1 | t_bool1 | t_null1 | t_empty_obj | t_empty_array | t_str2 | t_num_int2 | t_num_float2 | t_bool2 | t_null2 | t_new | cnt |
++-------------------------+-------+-----------+-------------+--------+--------+-------------+---------------+-----------------------------+----------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------+---------+--------+------------+--------------+---------+---------+-------------+---------------+--------+------------+--------------+---------+---------+-------+-----+
+| 2022-01-01 00:00:00.000 | A     |         1 |         0.1 |      1 |        | {}          | []            | {"o1":{},"o2":[],"o3":null} | [{},[],null]         | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
++-------------------------+-------+-----------+-------------+--------+--------+-------------+---------------+-----------------------------+----------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------+---------+--------+------------+--------------+---------+---------+-------------+---------------+--------+------------+--------------+---------+---------+-------+-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_sql TEST_ID: A017 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT *
+FROM test_json_cols
+OFFSET 1;
++-------------------------+-------+-----------+-------------+--------+--------+-------------+---------------+-----------------------------+----------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------+---------+--------+------------+--------------+---------+---------+-------------+---------------+--------+------------+--------------+---------+---------+-------+-----+
+| __time                  | s_str | s_num_int | s_num_float | s_bool | s_null | c_empty_obj | c_empty_array | c_empty_obj_nested          | c_empty_array_nested | c1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | c2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | t_obj | t_array | t_str1 | t_num_int1 | t_num_float1 | t_bool1 | t_null1 | t_empty_obj | t_empty_array | t_str2 | t_num_int2 | t_num_float2 | t_bool2 | t_null2 | t_new | cnt |
++-------------------------+-------+-----------+-------------+--------+--------+-------------+---------------+-----------------------------+----------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------+---------+--------+------------+--------------+---------+---------+-------------+---------------+--------+------------+--------------+---------+---------+-------+-----+
+| 2022-01-01 00:00:00.000 | A     |         1 |         0.1 |      1 |        | {}          | []            | {"o1":{},"o2":[],"o3":null} | [{},[],null]         | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
+| 2022-02-01 00:00:00.000 |       |           |             |        |        |             |               |                             |                      | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
+| 2022-02-01 00:00:00.000 |       |           |             |        |        |             |               |                             |                      | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
++-------------------------+-------+-----------+-------------+--------+--------+-------------+---------------+-----------------------------+----------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------+---------+--------+------------+--------------+---------+---------+-------------+---------------+--------+------------+--------------+---------+---------+-------+-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_sql TEST_ID: A018 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT *
+FROM test_json_cols
+UNION ALL
+SELECT *
+FROM test_json_cols;
++-------------------------+-------+-----------+-------------+--------+--------+-------------+---------------+-----------------------------+----------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------+---------+--------+------------+--------------+---------+---------+-------------+---------------+--------+------------+--------------+---------+---------+-------+-----+
+| __time                  | s_str | s_num_int | s_num_float | s_bool | s_null | c_empty_obj | c_empty_array | c_empty_obj_nested          | c_empty_array_nested | c1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | c2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | t_obj | t_array | t_str1 | t_num_int1 | t_num_float1 | t_bool1 | t_null1 | t_empty_obj | t_empty_array | t_str2 | t_num_int2 | t_num_float2 | t_bool2 | t_null2 | t_new | cnt |
++-------------------------+-------+-----------+-------------+--------+--------+-------------+---------------+-----------------------------+----------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------+---------+--------+------------+--------------+---------+---------+-------------+---------------+--------+------------+--------------+---------+---------+-------+-----+
+| 2022-01-01 00:00:00.000 | A     |         1 |         0.1 |      1 |        | {}          | []            | {"o1":{},"o2":[],"o3":null} | [{},[],null]         | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
+| 2022-01-01 00:00:00.000 | A     |         1 |         0.1 |      1 |        | {}          | []            | {"o1":{},"o2":[],"o3":null} | [{},[],null]         | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
+| 2022-01-01 00:00:00.000 | A     |         1 |         0.1 |      1 |        | {}          | []            | {"o1":{},"o2":[],"o3":null} | [{},[],null]         | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
+| 2022-01-01 00:00:00.000 | A     |         1 |         0.1 |      1 |        | {}          | []            | {"o1":{},"o2":[],"o3":null} | [{},[],null]         | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
+| 2022-02-01 00:00:00.000 |       |           |             |        |        |             |               |                             |                      | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
+| 2022-02-01 00:00:00.000 |       |           |             |        |        |             |               |                             |                      | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
+| 2022-02-01 00:00:00.000 |       |           |             |        |        |             |               |                             |                      | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
+| 2022-02-01 00:00:00.000 |       |           |             |        |        |             |               |                             |                      | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
++-------------------------+-------+-----------+-------------+--------+--------+-------------+---------------+-----------------------------+----------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------+---------+--------+------------+--------------+---------+---------+-------------+---------------+--------+------------+--------------+---------+---------+-------+-----+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_datatype_sql TEST_ID: A019 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT *
+FROM test_json_cols;
++-------------------------+-------+-----------+-------------+--------+--------+-------------+---------------+-----------------------------+----------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------+---------+--------+------------+--------------+---------+---------+-------------+---------------+--------+------------+--------------+---------+---------+-------+-----+
+| __time                  | s_str | s_num_int | s_num_float | s_bool | s_null | c_empty_obj | c_empty_array | c_empty_obj_nested          | c_empty_array_nested | c1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | c2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | t_obj | t_array | t_str1 | t_num_int1 | t_num_float1 | t_bool1 | t_null1 | t_empty_obj | t_empty_array | t_str2 | t_num_int2 | t_num_float2 | t_bool2 | t_null2 | t_new | cnt |
++-------------------------+-------+-----------+-------------+--------+--------+-------------+---------------+-----------------------------+----------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------+---------+--------+------------+--------------+---------+---------+-------------+---------------+--------+------------+--------------+---------+---------+-------+-----+
+| 2022-01-01 00:00:00.000 | A     |         1 |         0.1 |      1 |        | {}          | []            | {"o1":{},"o2":[],"o3":null} | [{},[],null]         | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
+| 2022-01-01 00:00:00.000 | A     |         1 |         0.1 |      1 |        | {}          | []            | {"o1":{},"o2":[],"o3":null} | [{},[],null]         | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} | {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
+| 2022-02-01 00:00:00.000 |       |           |             |        |        |             |               |                             |                      | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
+| 2022-02-01 00:00:00.000 |       |           |             |        |        |             |               |                             |                      | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} | {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} |       |         |        |            |              |         |         |             |               |        |            |              |         |         |       |   1 |
++-------------------------+-------+-----------+-------------+--------+--------+-------------+---------------+-----------------------------+----------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------+---------+--------+------------+--------------+---------+---------+-------------+---------------+--------+------------+--------------+---------+---------+-------+-----+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_json_cols"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "resultFormat" : "compactedList",
+  "columns" : [ "__time", "s_str", "s_num_int", "s_num_float", "s_bool", "s_null", "c_empty_obj", "c_empty_array", "c_empty_obj_nested", "c_empty_array_nested", "c1", "c2", "t_obj", "t_array", "t_str1", "t_num_int1", "t_num_float1", "t_bool1", "t_null1", "t_empty_obj", "t_empty_array", "t_str2", "t_num_int2", "t_num_float2", "t_bool2", "t_null2", "t_new", "cnt" ],
+  "columnTypes" : [ "LONG", "STRING", "LONG", "DOUBLE", "LONG", "STRING", "COMPLEX<json>", "ARRAY<LONG>", "COMPLEX<json>", "COMPLEX<json>", "COMPLEX<json>", "COMPLEX<json>", "STRING", "STRING", "STRING", "STRING", "STRING", "STRING", "STRING", "STRING", "STRING", "STRING", "LONG", "STRING", "STRING", "STRING", "STRING", "LONG" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A001 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(__time, '$') c
+FROM test_json_cols;
++---------------+
+| c             |
++---------------+
+| 1640995200000 |
+| 1640995200000 |
+| 1643673600000 |
+| 1643673600000 |
++---------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A002 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(__time, '$' RETURNING bigint) = 1640995200000;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A003 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(__time, '$' RETURNING bigint) <> 1640995200000;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A004 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(__time, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A005 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(__time, '$') IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A006 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value('ABCD', '$' RETURNING CHAR) c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| ABCD |
+| ABCD |
+| ABCD |
+| ABCD |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A007 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value('ABCD', '$' RETURNING CHAR) = 'ABCD';
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A008 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value('ABCD', '$' RETURNING CHAR) <> 'ABCD';
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A009 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value('ABCD', '$' RETURNING CHAR) IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A010 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value('ABCD', '$' RETURNING CHAR) IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A011 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(s_str, '$' RETURNING CHAR) c
+FROM test_json_cols;
++---+
+| c |
++---+
+| A |
+| A |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A012 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(s_str, '$' RETURNING CHAR) = 'A';
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A013 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(s_str, '$' RETURNING CHAR) <> 'A';
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A014 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(s_str, '$' RETURNING CHAR) IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A015 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(s_str, '$' RETURNING CHAR) IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A016 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(1234, '$' RETURNING int) c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| 1234 |
+| 1234 |
+| 1234 |
+| 1234 |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A017 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(1234, '$') = 1234;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A018 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(1234, '$') <> 1234;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A019 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(1234, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A020 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(1234, '$') IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A021 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(s_num_int, '$' RETURNING int) c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A022 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(s_num_int, '$' RETURNING int) = 1;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A023 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(s_num_int, '$' RETURNING int) <> 1;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A024 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(s_num_int, '$' RETURNING int) IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A025 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(s_num_int, '$' RETURNING int) IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A026 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(1234.5678, '$' RETURNING DOUBLE) c
+FROM test_json_cols;
++-----------+
+| c         |
++-----------+
+| 1234.5678 |
+| 1234.5678 |
+| 1234.5678 |
+| 1234.5678 |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A027 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(1234.5678, '$' RETURNING DOUBLE) = 1234.5678;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A028 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(1234.5678, '$' RETURNING DOUBLE) <> 1234.5678;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A029 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(1234.5678, '$' RETURNING DOUBLE) IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A030 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(1234.5678, '$' RETURNING DOUBLE) IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A031 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(s_num_float, '$' RETURNING DOUBLE) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A032 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(s_num_float, '$' RETURNING DOUBLE) = 0.1;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A033 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(s_num_float, '$' RETURNING DOUBLE) <> 0.1;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A034 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(s_num_float, '$' RETURNING DOUBLE) IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A035 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(s_num_float, '$' RETURNING DOUBLE) IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A036 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(NULL, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A037 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(NULL, '$') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A038 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(NULL, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A039 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(s_null, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A040 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(s_null, '$') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A041 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(s_null, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A042 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(c_empty_obj, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A043 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c_empty_obj, '$') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A044 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c_empty_obj, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A045 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(c_empty_array, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A046 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c_empty_array, '$') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A047 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c_empty_array, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A048 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(c_empty_obj_nested, '$.o1') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A049 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c_empty_obj_nested, '$.o1') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A050 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c_empty_obj_nested, '$.o1') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A051 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(c_empty_obj_nested, '$.o2') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A052 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(c_empty_obj_nested, '$.o2') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A053 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c_empty_obj_nested, '$.o2') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A054 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c_empty_obj_nested, '$.o2') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A055 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(c_empty_obj_nested, '$.o3') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A056 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c_empty_obj_nested, '$.o3') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A057 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c_empty_obj_nested, '$.o3') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A058 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(c_empty_array_nested, '$[0]') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A059 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c_empty_array_nested, '$[0]') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A060 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c_empty_array_nested, '$[0]') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A061 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(c_empty_array_nested, '$[1]') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A062 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(c_empty_array_nested, '$[1]') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A063 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c_empty_array_nested, '$[1]') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A064 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c_empty_array_nested, '$[1]') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A065 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(c_empty_array_nested, '$[2]') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A066 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c_empty_array_nested, '$[2]') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A067 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c_empty_array_nested, '$[2]') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A068 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.does.not.exist') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A069 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c_empty_obj_nested, '$.') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A070 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c_empty_array_nested, '$.') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A071 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_obj') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A072 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_array[0]') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A073 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_array[0,1]') IS NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A074 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_array[0:2]') IS NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A075 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_array[:2]') IS NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A076 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_array[0:]') IS NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A077 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_array[-1].a_str') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A078 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_array[-2].a_str') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A079 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_array[-1234567890].a_str') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A080 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_array[0].a_str.length()') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A081 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_array[0].a_str') = 'A';
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A082 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_array[1].a_str') = 'A';
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A083 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_array[2].a_str') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A084 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_array[1234567890].a_str') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A085 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_empty_obj') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A086 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_empty_array') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A087 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_empty_obj_nested.o1') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A088 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_empty_obj_nested.o2') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A089 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_empty_obj_nested.o3') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A090 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_empty_array_nested[0]') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A091 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_empty_array_nested[1]') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A092 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_empty_array_nested[2]') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A093 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_obj.a_str') = 'A';
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A094 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(s_str, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| A |
+| A |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A095 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_str') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| A |
+| A |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A096 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_obj.a_str') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| A |
+| A |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A097 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_array[0].a_str') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| A |
+| A |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A098 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(s_str, '$' RETURNING bigint) c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A099 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_str' RETURNING bigint) c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A100 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_obj.a_str' RETURNING bigint) c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A101 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_array[0].a_str' RETURNING bigint) c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A102 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(s_num_int, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A103 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_num_int') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A104 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_obj.a_num_int') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A105 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_array[0].a_num_int') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A106 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(s_num_int, '$' RETURNING bigint) c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A107 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_num_int' RETURNING bigint) c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A108 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_obj.a_num_int' RETURNING bigint) c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A109 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_array[0].a_num_int' RETURNING bigint) c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A110 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(s_num_int, '$') AS bigint) c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A111 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(c1, '$.a_num_int') AS bigint) c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A112 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(c1, '$.a_obj.a_num_int') AS bigint) c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A113 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(c1, '$.a_array[0].a_num_int') AS bigint) c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A114 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(s_num_float, '$') c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A115 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_num_float') c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A116 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_obj.a_num_float') c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A117 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_array[0].a_num_float') c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A118 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(s_num_float, '$' RETURNING DOUBLE) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A119 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_num_float' RETURNING DOUBLE) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A120 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_obj.a_num_float' RETURNING DOUBLE) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A121 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_array[0].a_num_float' RETURNING DOUBLE) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A122 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(s_num_float, '$') AS DOUBLE) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A123 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(c1, '$.a_num_float') AS DOUBLE) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A124 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(c1, '$.a_obj.a_num_float') AS DOUBLE) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A125 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(c1, '$.a_array[0].a_num_float') AS DOUBLE) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A126 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(s_bool, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A127 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_bool') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A128 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_obj.a_bool') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A129 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_array[0].a_bool') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A130 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(s_bool, '$' RETURNING boolean) c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A131 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_bool' RETURNING boolean) c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A132 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_obj.a_bool' RETURNING boolean) c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A133 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_array[0].a_bool' RETURNING boolean) c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A134 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(s_bool, '$') AS boolean) c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A135 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(c1, '$.a_bool') AS boolean) c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A136 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(c1, '$.a_obj.a_bool') AS boolean) c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A137 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT cast(json_value(c1, '$.a_array[0].a_bool') AS boolean) c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A138 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(s_null, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A139 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_null') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A140 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_obj.a_null') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A141 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_array[0].a_null') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A142 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(s_null, '$' RETURNING CHAR) c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A143 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_null' RETURNING BIGINT) c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A144 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_obj.a_null' RETURNING DOUBLE) c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A145 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_array[0].a_null' RETURNING BOOLEAN) c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A146 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_obj.a_str') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A147 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_obj.a_num_int') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A148 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_obj.a_num_float') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A149 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_obj.a_null') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A150 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.doesntexist') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A151 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_obj.a_str') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A152 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_obj.a_num_int') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A153 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_obj.a_num_float') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A154 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_obj.a_null') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A155 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.doesntexist') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A156 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT json_value(c1, '$.a_obj.a_str')
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A157 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT ALL json_value(c1, '$.a_obj.a_str')
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A158 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT json_value(c1, '$.a_obj.a_str') mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A159 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_value(c1, '$.a_obj.a_str') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| A |
+|   |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A160 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mycol,
+       count(*) c
+FROM
+  (SELECT json_value(c1, '$.a_obj.a_str') mycol
+   FROM test_json_cols)
+GROUP BY mycol;
++-------+---+
+| mycol | c |
++-------+---+
+| A     | 2 |
+|       | 2 |
++-------+---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A161 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mycol,
+       count(*) c
+FROM
+  (SELECT c1,
+          json_value(c1, '$.a_obj.a_str') mycol
+   FROM test_json_cols)
+GROUP BY mycol
+HAVING mycol = 'A';
++-------+---+
+| mycol | c |
++-------+---+
+| A     | 2 |
++-------+---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A162 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(c1, '$.a_obj.a_str') = json_value(c2, '$.a_obj.a_str');
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A163 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+INNER JOIN test_json_cols t2 ON json_value(t1.c1, '$.a_obj.a_str') = json_value(t2.c1, '$.a_obj.a_str');
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A164 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+LEFT JOIN test_json_cols t2 ON json_value(t1.c1, '$.a_obj.a_str') = json_value(t2.c1, '$.a_obj.a_str');
++---+
+| c |
++---+
+| 6 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A165 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1,
+     test_json_cols t2
+WHERE json_value(t1.c1, '$.a_obj.a_str') = json_value(t2.c1, '$.a_obj.a_str');
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A166 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_obj.a_str') c
+FROM test_json_cols
+ORDER BY __time;
++---+
+| c |
++---+
+| A |
+| A |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A167 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_obj.a_str') c
+FROM test_json_cols
+LIMIT 1;
++---+
+| c |
++---+
+| A |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A168 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_obj.a_str') c
+FROM test_json_cols
+OFFSET 1;
++---+
+| c |
++---+
+| A |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A169 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(c1, '$.a_obj.a_str') c
+FROM test_json_cols
+UNION ALL
+SELECT json_value(c1, '$.a_obj.a_str') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| A |
+| A |
+| A |
+| A |
+|   |
+|   |
+|   |
+|   |
++---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_value TEST_ID: A170 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_value(c1, '$.a_obj.a_str')
+FROM test_json_cols;
++--------+
+| EXPR$0 |
++--------+
+| A      |
+| A      |
+|        |
+|        |
++--------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_json_cols"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "nested-field",
+    "columnName" : "c1",
+    "outputName" : "v0",
+    "expectedType" : "STRING",
+    "pathParts" : [ {
+      "type" : "field",
+      "field" : "a_obj"
+    }, {
+      "type" : "field",
+      "field" : "a_str"
+    } ],
+    "processFromRaw" : false
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "STRING" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A001 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(__time, '$') c
+FROM test_json_cols;
++---------------+
+| c             |
++---------------+
+| 1640995200000 |
+| 1640995200000 |
+| 1643673600000 |
+| 1643673600000 |
++---------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A002 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(__time, '$'), '$' RETURNING bigint) = 1640995200000;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A003 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(__time, '$'), '$' RETURNING bigint) <> 1640995200000;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A004 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(__time, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A005 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(__time, '$') IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A006 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query('ABCD', '$') c
+FROM test_json_cols;
++--------+
+| c      |
++--------+
+| "ABCD" |
+| "ABCD" |
+| "ABCD" |
+| "ABCD" |
++--------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A007 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query('ABCD', '$'), '$' RETURNING CHAR) = 'ABCD';
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A008 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query('ABCD', '$'), '$' RETURNING CHAR) <> 'ABCD';
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A009 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query('ABCD', '$') IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A010 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query('ABCD', '$') IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A011 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(s_str, '$') c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| "A" |
+| "A" |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A012 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(s_str, '$'), '$' RETURNING CHAR) = 'A';
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A013 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(s_str, '$'), '$' RETURNING CHAR) <> 'A';
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A014 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(s_str, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A015 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(s_str, '$') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A016 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_query(1234, '$'), '$' RETURNING int) c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| 1234 |
+| 1234 |
+| 1234 |
+| 1234 |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A017 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(1234, '$'), '$' RETURNING int) = 1234;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A018 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(1234, '$'), '$' RETURNING int) <> 1234;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A019 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(1234, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A020 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(1234, '$') IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A021 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_query(s_num_int, '$'), '$' RETURNING int) c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A022 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(s_num_int, '$'), '$' RETURNING int) = 1;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A023 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(s_num_int, '$'), '$' RETURNING int) <> 1;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A024 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(s_num_int, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A025 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(s_num_int, '$') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A026 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_query(1234.5678, '$'), '$' RETURNING DOUBLE) c
+FROM test_json_cols;
++-----------+
+| c         |
++-----------+
+| 1234.5678 |
+| 1234.5678 |
+| 1234.5678 |
+| 1234.5678 |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A027 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(1234.5678, '$'), '$' RETURNING DOUBLE) = 1234.5678;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A028 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(1234.5678, '$'), '$' RETURNING DOUBLE) <> 1234.5678;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A029 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(1234.5678, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A030 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(1234.5678, '$') IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A031 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_value(json_query(s_num_float, '$'), '$' RETURNING DOUBLE) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A032 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(s_num_float, '$'), '$' RETURNING DOUBLE) = 0.1;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A033 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(s_num_float, '$'), '$' RETURNING DOUBLE) <> 0.1;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A034 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(s_num_float, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A035 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(s_num_float, '$') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A036 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(NULL, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A037 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(NULL, '$') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A038 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(NULL, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A039 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(s_null, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A040 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(s_null, '$') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A041 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(s_null, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A042 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.does.not.exist') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A043 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.does.not.exist') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A044 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(s_str, '$') c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| "A" |
+| "A" |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A045 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_str') c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| "A" |
+| "A" |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A046 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj.a_str') c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| "A" |
+| "A" |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A047 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_array[0].a_str') c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| "A" |
+| "A" |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A048 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_str') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A049 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_str') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A050 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(s_num_int, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A051 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_num_int') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A052 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj.a_num_int') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A053 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_array[0].a_num_int') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A054 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_num_int') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A055 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_num_int') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A056 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(s_num_float, '$') c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A057 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_num_float') c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A058 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj.a_num_float') c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A059 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_array[0].a_num_float') c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A060 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_num_float') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A061 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_num_float') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A062 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(s_bool, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A063 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_bool') c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A064 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj.a_bool') c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A065 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_array[0].a_bool') c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| true |
+| true |
+|      |
+|      |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A066 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_bool') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A067 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_bool') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A068 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(s_null, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A069 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_null') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A070 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj.a_null') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A071 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_array[0].a_null') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A072 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_null') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A073 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_null') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A074 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c_empty_obj, '$') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| {} |
+| {} |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A075 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c_empty_obj, '$') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A076 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c_empty_obj, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A077 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c_empty_array, '$') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| [] |
+| [] |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A078 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c_empty_array, '$') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A079 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c_empty_array, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A080 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c_empty_obj_nested, '$.o1') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| {} |
+| {} |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A081 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c_empty_obj_nested, '$.o1') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A082 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c_empty_obj_nested, '$.o1') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A083 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c_empty_obj_nested, '$.o2') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| [] |
+| [] |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A084 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c_empty_obj_nested, '$.o2') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A085 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c_empty_obj_nested, '$.o2') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A086 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c_empty_obj_nested, '$.o3') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A087 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c_empty_obj_nested, '$.o3') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A088 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c_empty_obj_nested, '$.o3') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A089 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c_empty_array_nested, '$[0]') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| {} |
+| {} |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A090 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c_empty_array_nested, '$[0]') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A091 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c_empty_array_nested, '$[0]') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A092 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c_empty_array_nested, '$[1]') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| [] |
+| [] |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A093 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c_empty_array_nested, '$[1]') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A094 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c_empty_array_nested, '$[1]') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A095 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c_empty_array_nested, '$[2]') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A096 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c_empty_array_nested, '$[2]') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A097 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c_empty_array_nested, '$[2]') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A098 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c_empty_obj_nested, '$.') c
+FROM test_json_cols;
++-----------------------------+
+| c                           |
++-----------------------------+
+| {"o1":{},"o2":[],"o3":null} |
+| {"o1":{},"o2":[],"o3":null} |
+|                             |
+|                             |
++-----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A099 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c_empty_obj_nested, '$.') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A100 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c_empty_array_nested, '$.') c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [{},[],null] |
+| [{},[],null] |
+|              |
+|              |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A101 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c_empty_array_nested, '$.') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A102 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj.a_obj') c
+FROM test_json_cols;
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                  |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]} |
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]} |
+|                                                                                                                                                                                                    |
+|                                                                                                                                                                                                    |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A103 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_obj.a_obj') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A104 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj.a_array[0]') c
+FROM test_json_cols;
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                  |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]} |
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]} |
+|                                                                                                                                                                                                    |
+|                                                                                                                                                                                                    |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A105 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_obj.a_array[0]') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A106 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_array[0,1]') IS NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A107 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_array[0:2]') IS NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A108 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_array[:2]') IS NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A109 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_array[0:]') IS NULL;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A110 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_array[-1].a_str') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A111 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_array[-2].a_str') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A112 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_array[-1234567890].a_str') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A113 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_array[0].a_str.length()') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A114 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_array[0].a_str') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A115 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_array[1].a_str') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A116 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_array[2].a_str') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A117 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_array[1234567890].a_str') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A118 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_obj.a_str') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A119 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_array[0].a_str'), '$') = 'A';
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A120 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_array[0].a_num_int'), '$') = 1;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A121 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_array[0].a_num_float'), '$') = 0.1;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A122 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_obj'), '$.a_array[0].a_str') = 'A';
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A123 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_obj'), '$.a_array[0].a_num_int') = 1;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A124 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_obj'), '$.a_array[0].a_num_float') = 0.1;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A125 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_array[1].a_str'), '$') = 'A';
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A126 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_array[1].a_num_int'), '$') = 1;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A127 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_array[1].a_num_float'), '$') = 0.1;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A128 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_obj'), '$.a_array[1].a_str') = 'A';
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A129 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_obj'), '$.a_array[1].a_num_int') = 1;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A130 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_obj'), '$.a_array[1].a_num_float') = 0.1;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A131 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_array[2].a_str'), '$') = 'A';
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A132 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_array[2].a_num_int'), '$') = 1;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A133 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_array[2].a_num_float'), '$') = 0.1;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A134 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_obj'), '$.a_array[2].a_str') = 'A';
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A135 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_obj'), '$.a_array[2].a_num_int') = 1;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A136 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_obj'), '$.a_array[2].a_num_float') = 0.1;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A137 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_array[1234567890].a_str'), '$') = 'A';
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A138 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_array[1234567890].a_num_int'), '$') = 1;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A139 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_array[1234567890].a_num_float'), '$') = 0.1;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A140 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_obj'), '$.a_array[1234567890].a_str') = 'A';
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A141 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_obj'), '$.a_array[1234567890].a_num_int') = 1;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A142 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_value(json_query(c1, '$.a_obj'), '$.a_array[1234567890].a_num_float') = 0.1;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A143 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_obj') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A144 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_obj.a_str') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A145 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_obj.a_num_int') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A146 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_obj') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A147 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_obj.a_str') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A148 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_obj.a_num_int') IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A149 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT json_query(c1, '$.a_obj')
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A150 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT ALL json_query(c1, '$.a_array')
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A151 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT json_query(c1, '$.a_obj.a_str')
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A152 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT ALL json_query(c1, '$.a_obj.a_num_int')
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A153 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT json_query(c1, '$.a_obj') mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A154 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT json_query(c1, '$.a_obj.a_str') mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A155 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT json_query(c1, '$.a_obj.a_num_int') mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A156 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT DISTINCT json_query(c1, '$.a_obj') c
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A157 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_query(c1, '$.a_obj.a_str') c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| "A" |
+|     |
++-----+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A158 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT json_query(c1, '$.a_obj.a_num_int') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+|   |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A159 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT json_query(c1, '$.a_obj') mycol
+   FROM test_json_cols)
+GROUP BY mycol;
++---+
+| c |
++---+
+| 2 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A160 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj.a_str') mycol
+FROM test_json_cols
+GROUP BY json_query(c1, '$.a_obj.a_str');
++-------+
+| mycol |
++-------+
+| "A"   |
+|       |
++-------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A161 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj.a_num_int') mycol
+FROM test_json_cols
+GROUP BY json_query(c1, '$.a_obj.a_num_int');
++-------+
+| mycol |
++-------+
+| 1     |
+|       |
++-------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A162 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT json_query(c1, '$.a_obj') mycol
+   FROM test_json_cols)
+GROUP BY mycol
+HAVING mycol IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A163 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mycol,
+       count(*) c
+FROM
+  (SELECT c1,
+          json_query(c1, '$.a_str') mycol
+   FROM test_json_cols)
+GROUP BY mycol
+HAVING mycol IS NOT NULL;
++-------+---+
+| mycol | c |
++-------+---+
+| "A"   | 2 |
++-------+---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A164 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mycol,
+       count(*) c
+FROM
+  (SELECT c1,
+          json_query(c1, '$.a_num_int') mycol
+   FROM test_json_cols)
+GROUP BY mycol
+HAVING mycol IS NOT NULL;
++-------+---+
+| mycol | c |
++-------+---+
+| 1     | 2 |
++-------+---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A165 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_obj') = json_query(c2, '$.a_obj');
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A166 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_obj.a_str') = json_query(c2, '$.a_obj.a_str');
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A167 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_query(c1, '$.a_obj.a_num_int') = json_query(c2, '$.a_obj.a_num_int');
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A168 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+INNER JOIN test_json_cols t2 ON json_query(t1.c1, '$.a_obj')=json_query(t2.c1, '$.a_obj');
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A169 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+INNER JOIN test_json_cols t2 ON json_query(t1.c1, '$.a_obj.a_str')=json_query(t2.c1, '$.a_obj.a_str');
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A170 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+INNER JOIN test_json_cols t2 ON json_query(t1.c1, '$.a_obj.a_num_int')=json_query(t2.c1, '$.a_obj.a_num_int');
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A171 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+LEFT JOIN test_json_cols t2 ON json_query(t1.c1, '$.a_obj')=json_query(t2.c1, '$.a_obj');
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A172 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+LEFT JOIN test_json_cols t2 ON json_query(t1.c1, '$.a_obj.a_str')=json_query(t2.c1, '$.a_obj.a_str');
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A173 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+LEFT JOIN test_json_cols t2 ON json_query(t1.c1, '$.a_obj.a_num_int')=json_query(t2.c1, '$.a_obj.a_num_int');
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A174 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1,
+     test_json_cols t2
+WHERE json_query(t1.c1, '$.a_obj')=json_query(t2.c1, '$.a_obj');
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A175 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1,
+     test_json_cols t2
+WHERE json_query(t1.c1, '$.a_obj.a_str')=json_query(t2.c1, '$.a_obj.a_str');
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A176 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1,
+     test_json_cols t2
+WHERE json_query(t1.c1, '$.a_obj.a_num_int')=json_query(t2.c1, '$.a_obj.a_num_int');
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A177 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj.a_array[0]') c
+FROM test_json_cols
+ORDER BY __time;
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                  |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]} |
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]} |
+|                                                                                                                                                                                                    |
+|                                                                                                                                                                                                    |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A178 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj.a_array[0].a_str') c
+FROM test_json_cols
+ORDER BY __time;
++-----+
+| c   |
++-----+
+| "A" |
+| "A" |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A179 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj.a_array[0].a_num_int') c
+FROM test_json_cols
+ORDER BY __time;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A180 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj') c
+FROM test_json_cols
+LIMIT 1;
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]} |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A181 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj.a_str') c
+FROM test_json_cols
+LIMIT 1;
++-----+
+| c   |
++-----+
+| "A" |
++-----+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A182 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj.a_num_int') c
+FROM test_json_cols
+LIMIT 1;
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A183 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj') c
+FROM test_json_cols
+OFFSET 1;
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]} |
+|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A184 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj.a_str') c
+FROM test_json_cols
+OFFSET 1;
++-----+
+| c   |
++-----+
+| "A" |
+|     |
+|     |
++-----+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A185 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj.a_num_int') c
+FROM test_json_cols
+OFFSET 1;
++---+
+| c |
++---+
+| 1 |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A186 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj.a_array[0]') c
+FROM test_json_cols
+UNION ALL
+SELECT json_query(c1, '$.a_obj.a_array[0]') c
+FROM test_json_cols;
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                  |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]} |
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]} |
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]} |
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]} |
+|                                                                                                                                                                                                    |
+|                                                                                                                                                                                                    |
+|                                                                                                                                                                                                    |
+|                                                                                                                                                                                                    |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A187 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj.a_array[0].a_str') c
+FROM test_json_cols
+UNION ALL
+SELECT json_query(c1, '$.a_obj.a_array[0].a_str') c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| "A" |
+| "A" |
+| "A" |
+| "A" |
+|     |
+|     |
+|     |
+|     |
++-----+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A188 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(c1, '$.a_obj.a_array[0].a_num_int') c
+FROM test_json_cols
+UNION ALL
+SELECT json_query(c1, '$.a_obj.a_array[0].a_num_int') c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
+|   |
+|   |
+|   |
+|   |
++---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A189 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_query(c1, '$.a_obj')
+FROM test_json_cols;
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| EXPR$0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]} |
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]} |
+|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_json_cols"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "nested-field",
+    "columnName" : "c1",
+    "outputName" : "v0",
+    "expectedType" : "COMPLEX<json>",
+    "pathParts" : [ {
+      "type" : "field",
+      "field" : "a_obj"
+    } ],
+    "processFromRaw" : true
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "COMPLEX<json>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A190 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_query(c1, '$.a_obj.a_str')
+FROM test_json_cols;
++--------+
+| EXPR$0 |
++--------+
+| "A"    |
+| "A"    |
+|        |
+|        |
++--------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_json_cols"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "nested-field",
+    "columnName" : "c1",
+    "outputName" : "v0",
+    "expectedType" : "COMPLEX<json>",
+    "pathParts" : [ {
+      "type" : "field",
+      "field" : "a_obj"
+    }, {
+      "type" : "field",
+      "field" : "a_str"
+    } ],
+    "processFromRaw" : true
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "COMPLEX<json>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_query TEST_ID: A191 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_query(c1, '$.a_obj.a_num_int')
+FROM test_json_cols;
++--------+
+| EXPR$0 |
++--------+
+| 1      |
+| 1      |
+|        |
+|        |
++--------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_json_cols"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "nested-field",
+    "columnName" : "c1",
+    "outputName" : "v0",
+    "expectedType" : "COMPLEX<json>",
+    "pathParts" : [ {
+      "type" : "field",
+      "field" : "a_obj"
+    }, {
+      "type" : "field",
+      "field" : "a_num_int"
+    } ],
+    "processFromRaw" : true
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "COMPLEX<json>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A001 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(value 'A' KEY 'a') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A002 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' vAlUe 'A') c
+FROM test_json_cols;
++-----------+
+| c         |
++-----------+
+| {"a":"A"} |
+| {"a":"A"} |
+| {"a":"A"} |
+| {"a":"A"} |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A003 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value 'A1', KEY 'b' value 'A2', KEY 'c' value 'A3') c
+FROM test_json_cols;
++------------------------------+
+| c                            |
++------------------------------+
+| {"a":"A1","b":"A2","c":"A3"} |
+| {"a":"A1","b":"A2","c":"A3"} |
+| {"a":"A1","b":"A2","c":"A3"} |
+| {"a":"A1","b":"A2","c":"A3"} |
++------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A004 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':'A1', 'b':'A2', 'c':'A3') c
+FROM test_json_cols;
++------------------------------+
+| c                            |
++------------------------------+
+| {"a":"A1","b":"A2","c":"A3"} |
+| {"a":"A1","b":"A2","c":"A3"} |
+| {"a":"A1","b":"A2","c":"A3"} |
+| {"a":"A1","b":"A2","c":"A3"} |
++------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A005 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'aAa' value 'A1', KEY 'AaA' value 'A2', KEY 'AAa' value 'A3') c
+FROM test_json_cols;
++------------------------------------+
+| c                                  |
++------------------------------------+
+| {"aAa":"A1","AaA":"A2","AAa":"A3"} |
+| {"aAa":"A1","AaA":"A2","AAa":"A3"} |
+| {"aAa":"A1","AaA":"A2","AAa":"A3"} |
+| {"aAa":"A1","AaA":"A2","AAa":"A3"} |
++------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A006 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('aAa':'A1', 'AaA':'A2', 'AAa':'A3') c
+FROM test_json_cols;
++------------------------------------+
+| c                                  |
++------------------------------------+
+| {"aAa":"A1","AaA":"A2","AAa":"A3"} |
+| {"aAa":"A1","AaA":"A2","AAa":"A3"} |
+| {"aAa":"A1","AaA":"A2","AAa":"A3"} |
+| {"aAa":"A1","AaA":"A2","AAa":"A3"} |
++------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A007 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'aaa' value 'A1', KEY 'aaa' value 'A2', KEY 'aaa' value 'A3') c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| {"aaa":"A3"} |
+| {"aaa":"A3"} |
+| {"aaa":"A3"} |
+| {"aaa":"A3"} |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A008 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('aaa':'A1', 'aaa':'A2', 'aaa':'A3') c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| {"aaa":"A3"} |
+| {"aaa":"A3"} |
+| {"aaa":"A3"} |
+| {"aaa":"A3"} |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A009 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value 'A') c
+FROM test_json_cols;
++-----------+
+| c         |
++-----------+
+| {"a":"A"} |
+| {"a":"A"} |
+| {"a":"A"} |
+| {"a":"A"} |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A010 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':'A') c
+FROM test_json_cols;
++-----------+
+| c         |
++-----------+
+| {"a":"A"} |
+| {"a":"A"} |
+| {"a":"A"} |
+| {"a":"A"} |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A011 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY '123' value 'A') c
+FROM test_json_cols;
++-------------+
+| c           |
++-------------+
+| {"123":"A"} |
+| {"123":"A"} |
+| {"123":"A"} |
+| {"123":"A"} |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A012 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('123':'A') c
+FROM test_json_cols;
++-------------+
+| c           |
++-------------+
+| {"123":"A"} |
+| {"123":"A"} |
+| {"123":"A"} |
+| {"123":"A"} |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A013 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY '日本' value 'A') c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"日本":"A"} |
+| {"日本":"A"} |
+| {"日本":"A"} |
+| {"日本":"A"} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A014 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('日本':'A') c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"日本":"A"} |
+| {"日本":"A"} |
+| {"日本":"A"} |
+| {"日本":"A"} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A015 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a'||'b'||'c' value 'A') c
+FROM test_json_cols;
++-------------+
+| c           |
++-------------+
+| {"abc":"A"} |
+| {"abc":"A"} |
+| {"abc":"A"} |
+| {"abc":"A"} |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A016 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a'||'b'||'c':'A') c
+FROM test_json_cols;
++-------------+
+| c           |
++-------------+
+| {"abc":"A"} |
+| {"abc":"A"} |
+| {"abc":"A"} |
+| {"abc":"A"} |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A017 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY '"This is My Key"' value 'A') c
+FROM test_json_cols;
++----------------------------+
+| c                          |
++----------------------------+
+| {"\"This is My Key\"":"A"} |
+| {"\"This is My Key\"":"A"} |
+| {"\"This is My Key\"":"A"} |
+| {"\"This is My Key\"":"A"} |
++----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A018 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('"This is My Key"':'A') c
+FROM test_json_cols;
++----------------------------+
+| c                          |
++----------------------------+
+| {"\"This is My Key\"":"A"} |
+| {"\"This is My Key\"":"A"} |
+| {"\"This is My Key\"":"A"} |
+| {"\"This is My Key\"":"A"} |
++----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A019 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY json_value(s_str, '$') value 'A') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A020 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(json_value(s_str, '$'):'A') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A021 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 123 value 'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A022 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(123:'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A023 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 1+1 value 'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A024 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(1+1:'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A025 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY json_value(s_num_int, '$' RETURNING bigint) value 'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A026 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(json_value(s_num_int, '$' RETURNING bigint):'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A027 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 0.123 value 'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A028 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(0.123:'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A029 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 0.1+0.1 value 'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A030 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(0.1+0.1:'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A031 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY json_value(s_num_float, '$' RETURNING DOUBLE) value 'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A032 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(json_value(s_num_float, '$' RETURNING DOUBLE):'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A033 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY TRUE value 'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A034 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(TRUE:'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A035 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY (1=2) value 'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A036 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object((1=2):'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A037 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY json_value(s_bool, '$' RETURNING boolean) value 'A') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A038 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(json_value(s_bool, '$' RETURNING boolean):'A') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A039 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY NULL value 'A') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A040 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(NULL:'A') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A041 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY json_value(s_null, '$') value 'A') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A042 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(json_value(s_null, '$'):'A') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A043 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY json_value(c1, '$.doesnotexist') value 'A') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A044 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(json_value(c1, '$.doesnotexist'):'A') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A045 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY __time value 'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A046 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(__time:'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A047 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY CURRENT_TIMESTAMP value 'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A048 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(CURRENT_TIMESTAMP:'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A049 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY c1 value 'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A050 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(c1:'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A051 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY json_query(c1, '$.a_array[0].a_obj') value 'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A052 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(json_query(c1, '$.a_array[0].a_obj'):'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A053 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY json_object(KEY c2 value 'B') value 'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A054 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(json_object(KEY c2 value 'B'):'A') c
+FROM test_json_cols;
+field name must be a STRING
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A055 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value 'A') c
+FROM test_json_cols;
++-----------+
+| c         |
++-----------+
+| {"a":"A"} |
+| {"a":"A"} |
+| {"a":"A"} |
+| {"a":"A"} |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A056 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':'A') c
+FROM test_json_cols;
++-----------+
+| c         |
++-----------+
+| {"a":"A"} |
+| {"a":"A"} |
+| {"a":"A"} |
+| {"a":"A"} |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A057 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value '123') c
+FROM test_json_cols;
++-------------+
+| c           |
++-------------+
+| {"a":"123"} |
+| {"a":"123"} |
+| {"a":"123"} |
+| {"a":"123"} |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A058 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':'123') c
+FROM test_json_cols;
++-------------+
+| c           |
++-------------+
+| {"a":"123"} |
+| {"a":"123"} |
+| {"a":"123"} |
+| {"a":"123"} |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A059 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value '日本') c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":"日本"} |
+| {"a":"日本"} |
+| {"a":"日本"} |
+| {"a":"日本"} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A060 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':'日本') c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":"日本"} |
+| {"a":"日本"} |
+| {"a":"日本"} |
+| {"a":"日本"} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A061 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value 'a'||'b'||'c') c
+FROM test_json_cols;
++-------------+
+| c           |
++-------------+
+| {"a":"abc"} |
+| {"a":"abc"} |
+| {"a":"abc"} |
+| {"a":"abc"} |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A062 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':'a'||'b'||'c') c
+FROM test_json_cols;
++-------------+
+| c           |
++-------------+
+| {"a":"abc"} |
+| {"a":"abc"} |
+| {"a":"abc"} |
+| {"a":"abc"} |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A063 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value '"This is My Key"') c
+FROM test_json_cols;
++----------------------------+
+| c                          |
++----------------------------+
+| {"a":"\"This is My Key\""} |
+| {"a":"\"This is My Key\""} |
+| {"a":"\"This is My Key\""} |
+| {"a":"\"This is My Key\""} |
++----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A064 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':'"This is My Key"') c
+FROM test_json_cols;
++----------------------------+
+| c                          |
++----------------------------+
+| {"a":"\"This is My Key\""} |
+| {"a":"\"This is My Key\""} |
+| {"a":"\"This is My Key\""} |
+| {"a":"\"This is My Key\""} |
++----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A065 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value json_value(s_str, '$')) c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":"A"}  |
+| {"a":"A"}  |
+| {"a":null} |
+| {"a":null} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A066 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':json_value(s_str, '$')) c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":"A"}  |
+| {"a":"A"}  |
+| {"a":null} |
+| {"a":null} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A067 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value 123) c
+FROM test_json_cols;
++-----------+
+| c         |
++-----------+
+| {"a":123} |
+| {"a":123} |
+| {"a":123} |
+| {"a":123} |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A068 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':123) c
+FROM test_json_cols;
++-----------+
+| c         |
++-----------+
+| {"a":123} |
+| {"a":123} |
+| {"a":123} |
+| {"a":123} |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A069 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value 1+1) c
+FROM test_json_cols;
++---------+
+| c       |
++---------+
+| {"a":2} |
+| {"a":2} |
+| {"a":2} |
+| {"a":2} |
++---------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A070 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':1+1) c
+FROM test_json_cols;
++---------+
+| c       |
++---------+
+| {"a":2} |
+| {"a":2} |
+| {"a":2} |
+| {"a":2} |
++---------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A071 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value json_value(s_num_int, '$' RETURNING bigint)) c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":1}    |
+| {"a":1}    |
+| {"a":null} |
+| {"a":null} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A072 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':json_value(s_num_int, '$' RETURNING bigint)) c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":1}    |
+| {"a":1}    |
+| {"a":null} |
+| {"a":null} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A073 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value 0.123) c
+FROM test_json_cols;
++-------------+
+| c           |
++-------------+
+| {"a":0.123} |
+| {"a":0.123} |
+| {"a":0.123} |
+| {"a":0.123} |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A074 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':0.123) c
+FROM test_json_cols;
++-------------+
+| c           |
++-------------+
+| {"a":0.123} |
+| {"a":0.123} |
+| {"a":0.123} |
+| {"a":0.123} |
++-------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A075 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value 0.1+0.1) c
+FROM test_json_cols;
++-----------+
+| c         |
++-----------+
+| {"a":0.2} |
+| {"a":0.2} |
+| {"a":0.2} |
+| {"a":0.2} |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A076 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':0.1+0.1) c
+FROM test_json_cols;
++-----------+
+| c         |
++-----------+
+| {"a":0.2} |
+| {"a":0.2} |
+| {"a":0.2} |
+| {"a":0.2} |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A077 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value json_value(s_num_float, '$' RETURNING DOUBLE)) c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":0.1}  |
+| {"a":0.1}  |
+| {"a":null} |
+| {"a":null} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A078 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':json_value(s_num_float, '$' RETURNING DOUBLE)) c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":0.1}  |
+| {"a":0.1}  |
+| {"a":null} |
+| {"a":null} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A079 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value TRUE) c
+FROM test_json_cols;
++---------+
+| c       |
++---------+
+| {"a":1} |
+| {"a":1} |
+| {"a":1} |
+| {"a":1} |
++---------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A080 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':true) c
+FROM test_json_cols;
++---------+
+| c       |
++---------+
+| {"a":1} |
+| {"a":1} |
+| {"a":1} |
+| {"a":1} |
++---------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A081 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value (1=2)) c
+FROM test_json_cols;
++---------+
+| c       |
++---------+
+| {"a":0} |
+| {"a":0} |
+| {"a":0} |
+| {"a":0} |
++---------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A082 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':(1=2)) c
+FROM test_json_cols;
++---------+
+| c       |
++---------+
+| {"a":0} |
+| {"a":0} |
+| {"a":0} |
+| {"a":0} |
++---------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A083 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value json_value(s_bool, '$' RETURNING boolean)) c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":1}    |
+| {"a":1}    |
+| {"a":null} |
+| {"a":null} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A084 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':json_value(s_bool, '$' RETURNING boolean)) c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":1}    |
+| {"a":1}    |
+| {"a":null} |
+| {"a":null} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A085 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value NULL) c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":null} |
+| {"a":null} |
+| {"a":null} |
+| {"a":null} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A086 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':null) c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":null} |
+| {"a":null} |
+| {"a":null} |
+| {"a":null} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A087 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value json_value(s_null, '$')) c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":null} |
+| {"a":null} |
+| {"a":null} |
+| {"a":null} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A088 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':json_value(s_null, '$')) c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":null} |
+| {"a":null} |
+| {"a":null} |
+| {"a":null} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A089 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value json_value(c1, '$.doesnotexist')) c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":null} |
+| {"a":null} |
+| {"a":null} |
+| {"a":null} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A090 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':json_value(c1, '$.doesnotexist')) c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":null} |
+| {"a":null} |
+| {"a":null} |
+| {"a":null} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A091 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value __time) c
+FROM test_json_cols;
++---------------------+
+| c                   |
++---------------------+
+| {"a":1640995200000} |
+| {"a":1640995200000} |
+| {"a":1643673600000} |
+| {"a":1643673600000} |
++---------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A092 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':__time) c
+FROM test_json_cols;
++---------------------+
+| c                   |
++---------------------+
+| {"a":1640995200000} |
+| {"a":1640995200000} |
+| {"a":1643673600000} |
+| {"a":1643673600000} |
++---------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A093 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT json_object(KEY 'a' value CURRENT_TIMESTAMP) c
+   FROM test_json_cols);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A094 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT json_object('a':current_timestamp) c
+   FROM test_json_cols);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A095 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value c_empty_obj) c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":null} |
+| {"a":null} |
+| {"a":{}}   |
+| {"a":{}}   |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A096 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':c_empty_obj) c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":null} |
+| {"a":null} |
+| {"a":{}}   |
+| {"a":{}}   |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A097 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value c_empty_array) c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":[]}   |
+| {"a":[]}   |
+| {"a":null} |
+| {"a":null} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A098 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':c_empty_array) c
+FROM test_json_cols;
++------------+
+| c          |
++------------+
+| {"a":[]}   |
+| {"a":[]}   |
+| {"a":null} |
+| {"a":null} |
++------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A099 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value c_empty_obj_nested) c
+FROM test_json_cols;
++-----------------------------------+
+| c                                 |
++-----------------------------------+
+| {"a":null}                        |
+| {"a":null}                        |
+| {"a":{"o1":{},"o2":[],"o3":null}} |
+| {"a":{"o1":{},"o2":[],"o3":null}} |
++-----------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A100 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':c_empty_obj_nested) c
+FROM test_json_cols;
++-----------------------------------+
+| c                                 |
++-----------------------------------+
+| {"a":null}                        |
+| {"a":null}                        |
+| {"a":{"o1":{},"o2":[],"o3":null}} |
+| {"a":{"o1":{},"o2":[],"o3":null}} |
++-----------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A101 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value c_empty_array_nested) c
+FROM test_json_cols;
++--------------------+
+| c                  |
++--------------------+
+| {"a":[{},[],null]} |
+| {"a":[{},[],null]} |
+| {"a":null}         |
+| {"a":null}         |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A102 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':c_empty_array_nested) c
+FROM test_json_cols;
++--------------------+
+| c                  |
++--------------------+
+| {"a":[{},[],null]} |
+| {"a":[{},[],null]} |
+| {"a":null}         |
+| {"a":null}         |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A103 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value c1) c
+FROM test_json_cols;
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"a":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]}} |
+| {"a":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]}} |
+| {"a":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]}} |
+| {"a":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]}} |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A104 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':c1) c
+FROM test_json_cols;
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"a":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]}} |
+| {"a":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]}} |
+| {"a":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]}} |
+| {"a":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]}} |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A105 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value json_query(c1, '$.a_array[0].a_obj')) c
+FROM test_json_cols;
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                        |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"a":null}                                                                                                                                                                                               |
+| {"a":null}                                                                                                                                                                                               |
+| {"a":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}} |
+| {"a":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}} |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A106 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':json_query(c1, '$.a_array[0].a_obj')) c
+FROM test_json_cols;
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                        |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"a":null}                                                                                                                                                                                               |
+| {"a":null}                                                                                                                                                                                               |
+| {"a":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}} |
+| {"a":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}} |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A107 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value json_object(KEY 'b' value 'B')) c
+FROM test_json_cols;
++-----------------+
+| c               |
++-----------------+
+| {"a":{"b":"B"}} |
+| {"a":{"b":"B"}} |
+| {"a":{"b":"B"}} |
+| {"a":{"b":"B"}} |
++-----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A108 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':json_object(KEY 'b' value 'B')) c
+FROM test_json_cols;
++-----------------+
+| c               |
++-----------------+
+| {"a":{"b":"B"}} |
+| {"a":{"b":"B"}} |
+| {"a":{"b":"B"}} |
+| {"a":{"b":"B"}} |
++-----------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A109 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_object(KEY 'a' value c1) IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A110 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_object('a':c1) IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A111 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_object(KEY 'a' value c1) IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A112 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_object('a':c1) IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A113 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT json_object(KEY 'a' value c1)
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A114 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT json_object('a':c1)
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A115 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT ALL json_object(KEY 'a' value c1)
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A116 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT ALL json_object('a':c1)
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A117 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT json_object(KEY 'a' value c1) mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A118 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT json_object('a':c1) mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A119 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT DISTINCT json_object(KEY 'a' value c1) c
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A120 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT DISTINCT json_object('a':c1) c
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A121 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT json_object(KEY 'a' value c1) mycol
+   FROM test_json_cols)
+GROUP BY mycol;
++---+
+| c |
++---+
+| 2 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A122 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT json_object('a':c1) mycol
+   FROM test_json_cols)
+GROUP BY mycol;
++---+
+| c |
++---+
+| 2 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A123 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT c1,
+          json_object(KEY 'a' value c1) mycol
+   FROM test_json_cols)
+GROUP BY mycol
+HAVING mycol IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A124 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT c1,
+          json_object('a':c1) mycol
+   FROM test_json_cols)
+GROUP BY mycol
+HAVING mycol IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A125 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_object(KEY 'a' value c1) = json_object(KEY 'a' value c1);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A126 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_object('a':c1) = json_object('a':c1);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A127 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+INNER JOIN test_json_cols t2 ON json_object(KEY 'a' value t1.c1)=json_object(KEY 'a' value t2.c1);
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A128 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+INNER JOIN test_json_cols t2 ON json_object('a':t1.c1)=json_object('a':t2.c1);
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A129 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+LEFT JOIN test_json_cols t2 ON json_object(KEY 'a' value t1.c1)=json_object(KEY 'a' value t2.c1);
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A130 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+LEFT JOIN test_json_cols t2 ON json_object('a':t1.c1)=json_object('a':t2.c1);
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A131 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1,
+     test_json_cols t2
+WHERE json_object(KEY 'a' value t1.c1)=json_object(KEY 'a' value t2.c1);
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A132 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1,
+     test_json_cols t2
+WHERE json_object('a':t1.c1)=json_object('a':t2.c1);
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A133 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value 'b') c
+FROM test_json_cols
+ORDER BY __time;
++-----------+
+| c         |
++-----------+
+| {"a":"b"} |
+| {"a":"b"} |
+| {"a":"b"} |
+| {"a":"b"} |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A134 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':'b') c
+FROM test_json_cols
+ORDER BY __time;
++-----------+
+| c         |
++-----------+
+| {"a":"b"} |
+| {"a":"b"} |
+| {"a":"b"} |
+| {"a":"b"} |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A135 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value 'b') c
+FROM test_json_cols
+LIMIT 1;
++-----------+
+| c         |
++-----------+
+| {"a":"b"} |
++-----------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A136 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':'b') c
+FROM test_json_cols
+LIMIT 1;
++-----------+
+| c         |
++-----------+
+| {"a":"b"} |
++-----------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A137 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value 'b') c
+FROM test_json_cols
+OFFSET 1;
++-----------+
+| c         |
++-----------+
+| {"a":"b"} |
+| {"a":"b"} |
+| {"a":"b"} |
++-----------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A138 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':'b') c
+FROM test_json_cols
+OFFSET 1;
++-----------+
+| c         |
++-----------+
+| {"a":"b"} |
+| {"a":"b"} |
+| {"a":"b"} |
++-----------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A139 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object(KEY 'a' value 'b') c
+FROM test_json_cols
+UNION ALL
+SELECT json_object(KEY 'a' value 'b') c
+FROM test_json_cols;
++-----------+
+| c         |
++-----------+
+| {"a":"b"} |
+| {"a":"b"} |
+| {"a":"b"} |
+| {"a":"b"} |
+| {"a":"b"} |
+| {"a":"b"} |
+| {"a":"b"} |
+| {"a":"b"} |
++-----------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A140 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_object('a':'b') c
+FROM test_json_cols
+UNION ALL
+SELECT json_object('a':'b') c
+FROM test_json_cols;
++-----------+
+| c         |
++-----------+
+| {"a":"b"} |
+| {"a":"b"} |
+| {"a":"b"} |
+| {"a":"b"} |
+| {"a":"b"} |
+| {"a":"b"} |
+| {"a":"b"} |
+| {"a":"b"} |
++-----------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A141 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_object(KEY 'a' value c1)
+FROM test_json_cols;
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| EXPR$0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"a":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]}} |
+| {"a":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]}} |
+| {"a":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]}} |
+| {"a":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]}} |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_json_cols"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "expression",
+    "name" : "v0",
+    "expression" : "json_object('a',\"c1\")",
+    "outputType" : "COMPLEX<json>"
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "COMPLEX<json>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_object TEST_ID: A142 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_object('a':c1)
+FROM test_json_cols;
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| EXPR$0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"a":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]}} |
+| {"a":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]}} |
+| {"a":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]}} |
+| {"a":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]}} |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_json_cols"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "expression",
+    "name" : "v0",
+    "expression" : "json_object('a',\"c1\")",
+    "outputType" : "COMPLEX<json>"
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "COMPLEX<json>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A001 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('1234') c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| 1234 |
+| 1234 |
+| 1234 |
+| 1234 |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A002 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('"日本"') c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| "日本" |
+| "日本" |
+| "日本" |
+| "日本" |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A003 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('"abc"') c
+FROM test_json_cols;
++-------+
+| c     |
++-------+
+| "abc" |
+| "abc" |
+| "abc" |
+| "abc" |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A004 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('"'||'a'||'b'||'c'||'"') c
+FROM test_json_cols;
++-------+
+| c     |
++-------+
+| "abc" |
+| "abc" |
+| "abc" |
+| "abc" |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A005 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('"This is My Key"') c
+FROM test_json_cols;
++------------------+
+| c                |
++------------------+
+| "This is My Key" |
+| "This is My Key" |
+| "This is My Key" |
+| "This is My Key" |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A006 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(parse_json('"AbCd"'), '$') c
+FROM test_json_cols;
++--------+
+| c      |
++--------+
+| "AbCd" |
+| "AbCd" |
+| "AbCd" |
+| "AbCd" |
++--------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A007 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(s_str, '$')) c
+FROM test_json_cols;
+ExpressionProcessingException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A008 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(1234) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A009 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(1+1) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A010 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(parse_json(1234), '$') c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A011 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(s_num_int, '$' RETURNING bigint)) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A012 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(0.1234) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A013 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(0.1+0.1) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A014 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(parse_json(0.1234), '$') c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A015 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(s_num_float, '$' RETURNING DOUBLE)) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A016 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(TRUE) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A017 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json((1=2)) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A018 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(parse_json(TRUE), '$') c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A019 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(s_bool, '$' RETURNING boolean)) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A020 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(NULL) c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A021 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(parse_json(NULL), '$') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A022 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_value(s_null, '$')) c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A023 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(__time) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A024 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(CURRENT_TIMESTAMP) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A025 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('{}') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| {} |
+| {} |
+| {} |
+| {} |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A026 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('{"a": "A", "b": {}}') c
+FROM test_json_cols;
++------------------+
+| c                |
++------------------+
+| {"a":"A","b":{}} |
+| {"a":"A","b":{}} |
+| {"a":"A","b":{}} |
+| {"a":"A","b":{}} |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A027 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('[]') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| [] |
+| [] |
+| [] |
+| [] |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A028 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('{"a": "A", "b": []}') c
+FROM test_json_cols;
++------------------+
+| c                |
++------------------+
+| {"a":"A","b":[]} |
+| {"a":"A","b":[]} |
+| {"a":"A","b":[]} |
+| {"a":"A","b":[]} |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A029 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('{"a": "A", "b": 1, "c": 0.1, "d": true, "e": null}') c
+FROM test_json_cols;
++-------------------------------------------+
+| c                                         |
++-------------------------------------------+
+| {"a":"A","b":1,"c":0.1,"d":true,"e":null} |
+| {"a":"A","b":1,"c":0.1,"d":true,"e":null} |
+| {"a":"A","b":1,"c":0.1,"d":true,"e":null} |
+| {"a":"A","b":1,"c":0.1,"d":true,"e":null} |
++-------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A030 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('{"a": "A", "b": [{"c": 123}, {"d": null, "e": [1, 2, 3]}]}') c
+FROM test_json_cols;
++--------------------------------------------------+
+| c                                                |
++--------------------------------------------------+
+| {"a":"A","b":[{"c":123},{"d":null,"e":[1,2,3]}]} |
+| {"a":"A","b":[{"c":123},{"d":null,"e":[1,2,3]}]} |
+| {"a":"A","b":[{"c":123},{"d":null,"e":[1,2,3]}]} |
+| {"a":"A","b":[{"c":123},{"d":null,"e":[1,2,3]}]} |
++--------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A031 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(c1) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A032 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(json_query(c1, '$.a_array[0].a_obj')) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A033 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('{'a': 123}') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A034 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('"a": 123') c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| "a" |
+| "a" |
+| "a" |
+| "a" |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A035 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('{"a": 123; "b": 456}') c
+FROM test_json_cols;
+ExpressionProcessingException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A036 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('{"a": 123 456}') c
+FROM test_json_cols;
+ExpressionProcessingException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A037 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('{"a": "A", "b": ["c": {}, "d": {}]}') c
+FROM test_json_cols;
+ExpressionProcessingException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A038 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE parse_json(to_json_string(c1)) IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A039 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE parse_json(to_json_string(c1)) IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A040 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT parse_json(to_json_string(c1))
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A041 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT ALL parse_json(to_json_string(c1))
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A042 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT parse_json(to_json_string(c1)) mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A043 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT DISTINCT parse_json(to_json_string(c1)) c
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A044 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT parse_json(to_json_string(c1)) mycol
+   FROM test_json_cols)
+GROUP BY mycol;
++---+
+| c |
++---+
+| 2 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A045 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT c1,
+          parse_json(to_json_string(c1)) mycol
+   FROM test_json_cols)
+GROUP BY mycol
+HAVING mycol IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A046 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE parse_json(to_json_string(c1)) = parse_json(to_json_string(c1));
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A047 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+INNER JOIN test_json_cols t2 ON parse_json(to_json_string(t1.c1))=parse_json(to_json_string(t2.c1));
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A048 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+LEFT JOIN test_json_cols t2 ON parse_json(to_json_string(t1.c1))=parse_json(to_json_string(t2.c1));
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A049 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1,
+     test_json_cols t2
+WHERE parse_json(to_json_string(t1.c1))=parse_json(to_json_string(t2.c1));
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A050 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('{"a": "A", "b": 123, "c": true, "d": null}') c
+FROM test_json_cols
+ORDER BY __time;
++-------------------------------------+
+| c                                   |
++-------------------------------------+
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
++-------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A051 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('{"a": "A", "b": 123, "c": true, "d": null}') c
+FROM test_json_cols
+LIMIT 1;
++-------------------------------------+
+| c                                   |
++-------------------------------------+
+| {"a":"A","b":123,"c":true,"d":null} |
++-------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A052 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('{"a": "A", "b": 123, "c": true, "d": null}') c
+FROM test_json_cols
+OFFSET 1;
++-------------------------------------+
+| c                                   |
++-------------------------------------+
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
++-------------------------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A053 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json('{"a": "A", "b": 123, "c": true, "d": null}') c
+FROM test_json_cols
+UNION ALL
+SELECT parse_json('{"a": "A", "b": 123, "c": true, "d": null}') c
+FROM test_json_cols;
++-------------------------------------+
+| c                                   |
++-------------------------------------+
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
++-------------------------------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_parse_json TEST_ID: A054 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT parse_json(to_json_string(c1))
+FROM test_json_cols;
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| EXPR$0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} |
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} |
+| {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} |
+| {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_json_cols"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "expression",
+    "name" : "v0",
+    "expression" : "parse_json(to_json_string(\"c1\"))",
+    "outputType" : "COMPLEX<json>"
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "COMPLEX<json>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A001 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('1234') c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| 1234 |
+| 1234 |
+| 1234 |
+| 1234 |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A002 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('"日本"') c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| "日本" |
+| "日本" |
+| "日本" |
+| "日本" |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A003 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('"abc"') c
+FROM test_json_cols;
++-------+
+| c     |
++-------+
+| "abc" |
+| "abc" |
+| "abc" |
+| "abc" |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A004 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('"'||'a'||'b'||'c'||'"') c
+FROM test_json_cols;
++-------+
+| c     |
++-------+
+| "abc" |
+| "abc" |
+| "abc" |
+| "abc" |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A005 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('"This is My Key"') c
+FROM test_json_cols;
++------------------+
+| c                |
++------------------+
+| "This is My Key" |
+| "This is My Key" |
+| "This is My Key" |
+| "This is My Key" |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A006 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(try_parse_json('"AbCd"'), '$') c
+FROM test_json_cols;
++--------+
+| c      |
++--------+
+| "AbCd" |
+| "AbCd" |
+| "AbCd" |
+| "AbCd" |
++--------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A007 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(s_str, '$')) c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A008 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(1234) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A009 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(1+1) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A010 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(try_parse_json(1234), '$') c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A011 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(s_num_int, '$' RETURNING bigint)) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A012 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(0.1234) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A013 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(0.1+0.1) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A014 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(try_parse_json(0.1234), '$') c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A015 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(s_num_float, '$' RETURNING DOUBLE)) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A016 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(TRUE) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A017 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json((1=2)) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A018 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(try_parse_json(TRUE), '$') c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A019 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(s_bool, '$' RETURNING boolean)) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A020 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(NULL) c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A021 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_query(try_parse_json(NULL), '$') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A022 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_value(s_null, '$')) c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A023 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(__time) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A024 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(CURRENT_TIMESTAMP) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A025 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('{}') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| {} |
+| {} |
+| {} |
+| {} |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A026 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('{"a": "A", "b": {}}') c
+FROM test_json_cols;
++------------------+
+| c                |
++------------------+
+| {"a":"A","b":{}} |
+| {"a":"A","b":{}} |
+| {"a":"A","b":{}} |
+| {"a":"A","b":{}} |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A027 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('[]') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| [] |
+| [] |
+| [] |
+| [] |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A028 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('{"a": "A", "b": []}') c
+FROM test_json_cols;
++------------------+
+| c                |
++------------------+
+| {"a":"A","b":[]} |
+| {"a":"A","b":[]} |
+| {"a":"A","b":[]} |
+| {"a":"A","b":[]} |
++------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A029 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('{"a": "A", "b": 1, "c": 0.1, "d": true, "e": null}') c
+FROM test_json_cols;
++-------------------------------------------+
+| c                                         |
++-------------------------------------------+
+| {"a":"A","b":1,"c":0.1,"d":true,"e":null} |
+| {"a":"A","b":1,"c":0.1,"d":true,"e":null} |
+| {"a":"A","b":1,"c":0.1,"d":true,"e":null} |
+| {"a":"A","b":1,"c":0.1,"d":true,"e":null} |
++-------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A030 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('{"a": "A", "b": [{"c": 123}, {"d": null, "e": [1, 2, 3]}]}') c
+FROM test_json_cols;
++--------------------------------------------------+
+| c                                                |
++--------------------------------------------------+
+| {"a":"A","b":[{"c":123},{"d":null,"e":[1,2,3]}]} |
+| {"a":"A","b":[{"c":123},{"d":null,"e":[1,2,3]}]} |
+| {"a":"A","b":[{"c":123},{"d":null,"e":[1,2,3]}]} |
+| {"a":"A","b":[{"c":123},{"d":null,"e":[1,2,3]}]} |
++--------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A031 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(c1) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A032 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(json_query(c1, '$.a_array[0].a_obj')) c
+FROM test_json_cols;
+Cannot apply
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A033 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('{'a': 123}') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A034 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('"a": 123') c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| "a" |
+| "a" |
+| "a" |
+| "a" |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A035 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('{"a": 123; "b": 456}') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A036 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('{"a": 123 456}') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A037 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('{"a": "A", "b": ["c": {}, "d": {}]}') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A038 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(to_json_string(c_empty_obj)) c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| {} |
+| {} |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A039 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(to_json_string(c_empty_array)) c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| [] |
+| [] |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A040 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(to_json_string(c_empty_obj_nested)) c
+FROM test_json_cols;
++-----------------------------+
+| c                           |
++-----------------------------+
+| {"o1":{},"o2":[],"o3":null} |
+| {"o1":{},"o2":[],"o3":null} |
+|                             |
+|                             |
++-----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A041 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json(to_json_string(c_empty_array_nested)) c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [{},[],null] |
+| [{},[],null] |
+|              |
+|              |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A042 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE try_parse_json(to_json_string(c1)) IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A043 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE try_parse_json(to_json_string(c1)) IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A044 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT try_parse_json(to_json_string(c1))
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A045 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT ALL try_parse_json(to_json_string(c1))
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A046 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT try_parse_json(to_json_string(c1)) mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A047 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT DISTINCT try_parse_json(to_json_string(c1)) c
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A048 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT try_parse_json(to_json_string(c1)) mycol
+   FROM test_json_cols)
+GROUP BY mycol;
++---+
+| c |
++---+
+| 2 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A049 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT c1,
+          try_parse_json(to_json_string(c1)) mycol
+   FROM test_json_cols)
+GROUP BY mycol
+HAVING mycol IS NOT NULL;
++---+
+| c |
++---+
+| 2 |
+| 2 |
++---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A050 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE try_parse_json(to_json_string(c1)) = try_parse_json(to_json_string(c1));
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A051 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+INNER JOIN test_json_cols t2 ON try_parse_json(to_json_string(t1.c1))=try_parse_json(to_json_string(t2.c1));
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A052 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+LEFT JOIN test_json_cols t2 ON try_parse_json(to_json_string(t1.c1))=try_parse_json(to_json_string(t2.c1));
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A053 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1,
+     test_json_cols t2
+WHERE try_parse_json(to_json_string(t1.c1))=try_parse_json(to_json_string(t2.c1));
+Cannot join
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A054 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('{"a": "A", "b": 123, "c": true, "d": null}') c
+FROM test_json_cols
+ORDER BY __time;
++-------------------------------------+
+| c                                   |
++-------------------------------------+
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
++-------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A055 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('{"a": "A", "b": 123, "c": true, "d": null}') c
+FROM test_json_cols
+LIMIT 1;
++-------------------------------------+
+| c                                   |
++-------------------------------------+
+| {"a":"A","b":123,"c":true,"d":null} |
++-------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A056 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('{"a": "A", "b": 123, "c": true, "d": null}') c
+FROM test_json_cols
+OFFSET 1;
++-------------------------------------+
+| c                                   |
++-------------------------------------+
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
++-------------------------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A057 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT try_parse_json('{"a": "A", "b": 123, "c": true, "d": null}') c
+FROM test_json_cols
+UNION ALL
+SELECT parse_json('{"a": "A", "b": 123, "c": true, "d": null}') c
+FROM test_json_cols;
++-------------------------------------+
+| c                                   |
++-------------------------------------+
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
+| {"a":"A","b":123,"c":true,"d":null} |
++-------------------------------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_try_parse_json TEST_ID: A058 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT try_parse_json(to_json_string(c1))
+FROM test_json_cols;
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| EXPR$0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} |
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} |
+| {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} |
+| {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_json_cols"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "expression",
+    "name" : "v0",
+    "expression" : "try_parse_json(to_json_string(\"c1\"))",
+    "outputType" : "COMPLEX<json>"
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "COMPLEX<json>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A001 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('1234') c
+FROM test_json_cols;
++--------+
+| c      |
++--------+
+| "1234" |
+| "1234" |
+| "1234" |
+| "1234" |
++--------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A002 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('日本') c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| "日本" |
+| "日本" |
+| "日本" |
+| "日本" |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A003 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('abc') c
+FROM test_json_cols;
++-------+
+| c     |
++-------+
+| "abc" |
+| "abc" |
+| "abc" |
+| "abc" |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A004 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('a'||'b'||'c') c
+FROM test_json_cols;
++-------+
+| c     |
++-------+
+| "abc" |
+| "abc" |
+| "abc" |
+| "abc" |
++-------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A005 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('"This is My Key"') c
+FROM test_json_cols;
++----------------------+
+| c                    |
++----------------------+
+| "\"This is My Key\"" |
+| "\"This is My Key\"" |
+| "\"This is My Key\"" |
+| "\"This is My Key\"" |
++----------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A006 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(to_json_string('AbCd')) c
+FROM test_json_cols;
++--------+
+| c      |
++--------+
+| "AbCd" |
+| "AbCd" |
+| "AbCd" |
+| "AbCd" |
++--------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A007 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(s_str, '$')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| "A" |
+| "A" |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A008 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(1234) c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| 1234 |
+| 1234 |
+| 1234 |
+| 1234 |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A009 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(1+1) c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 2 |
+| 2 |
+| 2 |
+| 2 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A010 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(to_json_string(1234)) c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| 1234 |
+| 1234 |
+| 1234 |
+| 1234 |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A011 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(s_num_int, '$' RETURNING bigint)) c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A012 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(0.1234) c
+FROM test_json_cols;
++--------+
+| c      |
++--------+
+| 0.1234 |
+| 0.1234 |
+| 0.1234 |
+| 0.1234 |
++--------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A013 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(0.1+0.1) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.2 |
+| 0.2 |
+| 0.2 |
+| 0.2 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A014 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(to_json_string(0.1234)) c
+FROM test_json_cols;
++--------+
+| c      |
++--------+
+| 0.1234 |
+| 0.1234 |
+| 0.1234 |
+| 0.1234 |
++--------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A015 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(s_num_float, '$' RETURNING DOUBLE)) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 0.1 |
+| 0.1 |
+|     |
+|     |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A016 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(TRUE) c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A017 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string((1=2)) c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 0 |
+| 0 |
+| 0 |
+| 0 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A018 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(to_json_string(TRUE)) c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+| 1 |
+| 1 |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A019 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(s_bool, '$' RETURNING boolean)) c
+FROM test_json_cols;
++---+
+| c |
++---+
+| 1 |
+| 1 |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A020 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(NULL) c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A021 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT parse_json(to_json_string(NULL)) c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A022 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_value(s_null, '$')) c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A023 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(__time) c
+FROM test_json_cols;
++---------------+
+| c             |
++---------------+
+| 1640995200000 |
+| 1640995200000 |
+| 1643673600000 |
+| 1643673600000 |
++---------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A024 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*)
+FROM
+  (SELECT to_json_string(CURRENT_TIMESTAMP) c
+   FROM test_json_cols);
++--------+
+| EXPR$0 |
++--------+
+|      4 |
++--------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A025 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('{}') c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| "{}" |
+| "{}" |
+| "{}" |
+| "{}" |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A026 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('{"a": "A", "b": {}}') c
+FROM test_json_cols;
++-----------------------------+
+| c                           |
++-----------------------------+
+| "{\"a\": \"A\", \"b\": {}}" |
+| "{\"a\": \"A\", \"b\": {}}" |
+| "{\"a\": \"A\", \"b\": {}}" |
+| "{\"a\": \"A\", \"b\": {}}" |
++-----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A027 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('[]') c
+FROM test_json_cols;
++------+
+| c    |
++------+
+| "[]" |
+| "[]" |
+| "[]" |
+| "[]" |
++------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A028 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('{"a": "A", "b": []}') c
+FROM test_json_cols;
++-----------------------------+
+| c                           |
++-----------------------------+
+| "{\"a\": \"A\", \"b\": []}" |
+| "{\"a\": \"A\", \"b\": []}" |
+| "{\"a\": \"A\", \"b\": []}" |
+| "{\"a\": \"A\", \"b\": []}" |
++-----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A029 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('{"a": "A", "b": 1, "c": 0.1, "d": true, "e": null}') c
+FROM test_json_cols;
++------------------------------------------------------------------+
+| c                                                                |
++------------------------------------------------------------------+
+| "{\"a\": \"A\", \"b\": 1, \"c\": 0.1, \"d\": true, \"e\": null}" |
+| "{\"a\": \"A\", \"b\": 1, \"c\": 0.1, \"d\": true, \"e\": null}" |
+| "{\"a\": \"A\", \"b\": 1, \"c\": 0.1, \"d\": true, \"e\": null}" |
+| "{\"a\": \"A\", \"b\": 1, \"c\": 0.1, \"d\": true, \"e\": null}" |
++------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A030 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('{"a": "A", "b": [{"c": 123}, {"d": null, "e": [1, 2, 3]}]}') c
+FROM test_json_cols;
++--------------------------------------------------------------------------+
+| c                                                                        |
++--------------------------------------------------------------------------+
+| "{\"a\": \"A\", \"b\": [{\"c\": 123}, {\"d\": null, \"e\": [1, 2, 3]}]}" |
+| "{\"a\": \"A\", \"b\": [{\"c\": 123}, {\"d\": null, \"e\": [1, 2, 3]}]}" |
+| "{\"a\": \"A\", \"b\": [{\"c\": 123}, {\"d\": null, \"e\": [1, 2, 3]}]}" |
+| "{\"a\": \"A\", \"b\": [{\"c\": 123}, {\"d\": null, \"e\": [1, 2, 3]}]}" |
++--------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A031 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(c1) c
+FROM test_json_cols;
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} |
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} |
+| {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} |
+| {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A032 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_query(c1, '$.a_array[0].a_obj')) c
+FROM test_json_cols;
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                  |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]} |
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]} |
+|                                                                                                                                                                                                    |
+|                                                                                                                                                                                                    |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A033 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(json_object('c1': c1, 'c2': c2)) c
+FROM test_json_cols;
++-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
++-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"c1":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]},"c2":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]}} |
+| {"c1":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]},"c2":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]}} |
+| {"c1":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]},"c2":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]}} |
+| {"c1":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]},"c2":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]}} |
++-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A034 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(c_empty_obj) c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| {} |
+| {} |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A035 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(c_empty_array) c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| [] |
+| [] |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A036 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(c_empty_obj_nested) c
+FROM test_json_cols;
++-----------------------------+
+| c                           |
++-----------------------------+
+| {"o1":{},"o2":[],"o3":null} |
+| {"o1":{},"o2":[],"o3":null} |
+|                             |
+|                             |
++-----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A037 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string(c_empty_array_nested) c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [{},[],null] |
+| [{},[],null] |
+|              |
+|              |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A038 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('{'a': 123}') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A039 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('"a": 123') c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| "\"a\": 123" |
+| "\"a\": 123" |
+| "\"a\": 123" |
+| "\"a\": 123" |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A040 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('{"a": 123; "b": 456}') c
+FROM test_json_cols;
++----------------------------+
+| c                          |
++----------------------------+
+| "{\"a\": 123; \"b\": 456}" |
+| "{\"a\": 123; \"b\": 456}" |
+| "{\"a\": 123; \"b\": 456}" |
+| "{\"a\": 123; \"b\": 456}" |
++----------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A041 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('{"a": 123 456}') c
+FROM test_json_cols;
++--------------------+
+| c                  |
++--------------------+
+| "{\"a\": 123 456}" |
+| "{\"a\": 123 456}" |
+| "{\"a\": 123 456}" |
+| "{\"a\": 123 456}" |
++--------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A042 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('{"a": "A", "b": ["c": {}, "d": {}]}') c
+FROM test_json_cols;
++-------------------------------------------------+
+| c                                               |
++-------------------------------------------------+
+| "{\"a\": \"A\", \"b\": [\"c\": {}, \"d\": {}]}" |
+| "{\"a\": \"A\", \"b\": [\"c\": {}, \"d\": {}]}" |
+| "{\"a\": \"A\", \"b\": [\"c\": {}, \"d\": {}]}" |
+| "{\"a\": \"A\", \"b\": [\"c\": {}, \"d\": {}]}" |
++-------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A043 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE to_json_string(c1) IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A044 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE to_json_string(c1) IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A045 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT to_json_string(c1)
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A046 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT ALL to_json_string(c1)
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A047 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT to_json_string(c1) mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A048 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT DISTINCT to_json_string(json_query(c1, '$.a_array[0].a_obj')) c
+FROM test_json_cols;
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                  |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]} |
+|                                                                                                                                                                                                    |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A049 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mycol,
+       count(*) c
+FROM
+  (SELECT to_json_string(json_query(c1, '$.a_array[0].a_obj')) mycol
+   FROM test_json_cols)
+GROUP BY mycol;
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---+
+| mycol                                                                                                                                                                                              | c |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---+
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]} | 2 |
+|                                                                                                                                                                                                    | 2 |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A050 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mycol,
+       count(*) c
+FROM
+  (SELECT c1,
+          to_json_string(json_query(c1, '$.a_array[0].a_obj')) mycol
+   FROM test_json_cols)
+GROUP BY mycol
+HAVING mycol IS NOT NULL;
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---+
+| mycol                                                                                                                                                                                              | c |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---+
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]} | 2 |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A051 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE to_json_string(c1) = to_json_string(c1);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A052 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+INNER JOIN test_json_cols t2 ON to_json_string(t1.c1)=to_json_string(t2.c1);
++---+
+| c |
++---+
+| 8 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A053 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+LEFT JOIN test_json_cols t2 ON to_json_string(t1.c1)=to_json_string(t2.c1);
++---+
+| c |
++---+
+| 8 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A054 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1,
+     test_json_cols t2
+WHERE to_json_string(t1.c1)=to_json_string(t2.c1);
++---+
+| c |
++---+
+| 8 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A055 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('{"a": "A", "b": 123, "c": true, "d": null}') c
+FROM test_json_cols
+ORDER BY __time;
++--------------------------------------------------------+
+| c                                                      |
++--------------------------------------------------------+
+| "{\"a\": \"A\", \"b\": 123, \"c\": true, \"d\": null}" |
+| "{\"a\": \"A\", \"b\": 123, \"c\": true, \"d\": null}" |
+| "{\"a\": \"A\", \"b\": 123, \"c\": true, \"d\": null}" |
+| "{\"a\": \"A\", \"b\": 123, \"c\": true, \"d\": null}" |
++--------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A056 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('{"a": "A", "b": 123, "c": true, "d": null}') c
+FROM test_json_cols
+LIMIT 1;
++--------------------------------------------------------+
+| c                                                      |
++--------------------------------------------------------+
+| "{\"a\": \"A\", \"b\": 123, \"c\": true, \"d\": null}" |
++--------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A057 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('{"a": "A", "b": 123, "c": true, "d": null}') c
+FROM test_json_cols
+OFFSET 1;
++--------------------------------------------------------+
+| c                                                      |
++--------------------------------------------------------+
+| "{\"a\": \"A\", \"b\": 123, \"c\": true, \"d\": null}" |
+| "{\"a\": \"A\", \"b\": 123, \"c\": true, \"d\": null}" |
+| "{\"a\": \"A\", \"b\": 123, \"c\": true, \"d\": null}" |
++--------------------------------------------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A058 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT to_json_string('{"a": "A", "b": 123, "c": true, "d": null}') c
+FROM test_json_cols
+UNION ALL
+SELECT to_json_string('{"a": "A", "b": 123, "c": true, "d": null}') c
+FROM test_json_cols;
++--------------------------------------------------------+
+| c                                                      |
++--------------------------------------------------------+
+| "{\"a\": \"A\", \"b\": 123, \"c\": true, \"d\": null}" |
+| "{\"a\": \"A\", \"b\": 123, \"c\": true, \"d\": null}" |
+| "{\"a\": \"A\", \"b\": 123, \"c\": true, \"d\": null}" |
+| "{\"a\": \"A\", \"b\": 123, \"c\": true, \"d\": null}" |
+| "{\"a\": \"A\", \"b\": 123, \"c\": true, \"d\": null}" |
+| "{\"a\": \"A\", \"b\": 123, \"c\": true, \"d\": null}" |
+| "{\"a\": \"A\", \"b\": 123, \"c\": true, \"d\": null}" |
+| "{\"a\": \"A\", \"b\": 123, \"c\": true, \"d\": null}" |
++--------------------------------------------------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_to_json_string TEST_ID: A059 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT to_json_string(c1)
+FROM test_json_cols;
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| EXPR$0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} |
+| {"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null],"a_obj":{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},"a_array":[{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]},{"a_str":"A","a_num_int":1,"a_num_float":0.1,"a_bool":true,"a_null":null,"a_empty_obj":{},"a_empty_array":[],"a_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"a_empty_array_nested":[{},[],null]}]}]} |
+| {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} |
+| {"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null],"b_obj":{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},"b_array":[{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]},{"b_str":"A","b_num_int":1,"b_num_float":0.1,"b_bool":true,"b_null":null,"b_empty_obj":{},"b_empty_array":[],"b_empty_obj_nested":{"o1":{},"o2":[],"o3":null},"b_empty_array_nested":[{},[],null]}]}]} |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_json_cols"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "expression",
+    "name" : "v0",
+    "expression" : "to_json_string(\"c1\")",
+    "outputType" : "STRING"
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "STRING" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A001 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(__time, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A002 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(__time, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A003 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(__time, '$') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A004 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys('ABCD', '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A005 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys('ABCD', '$') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A006 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys('ABCD', '$') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A007 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(s_str, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A008 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(s_str, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A009 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(s_str, '$') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A010 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(1234, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A011 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(1234, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A012 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(1234, '$') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A013 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(s_num_int, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A014 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(s_num_int, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A015 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(s_num_int, '$') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A016 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(1234.5678, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A017 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(1234.5678, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A018 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(1234.5678, '$') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A019 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(s_num_float, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A020 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(s_num_float, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A021 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(s_num_float, '$') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A022 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(NULL, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A023 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(NULL, '$') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A024 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(NULL, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A025 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(s_null, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A026 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(s_null, '$') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A027 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(s_null, '$') IS NOT NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A028 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.does.not.exist') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A029 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(c1, '$.does.not.exist') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A030 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0,1]') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A031 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0:2]') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A032 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[:2]') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A033 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0:]') c
+FROM test_json_cols;
+QueryInterruptedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A034 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[-1].a_str') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A035 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[-2].a_str') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A036 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[-1234567890].a_str') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A037 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0].a_str.length()') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A038 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(s_str, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A039 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(s_num_int, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A040 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(s_num_float, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A041 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(s_null, '$') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A042 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c_empty_obj, '$') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| [] |
+| [] |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A043 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c_empty_array, '$') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| [] |
+| [] |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A044 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c_empty_obj_nested, '$') c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [o1, o2, o3] |
+| [o1, o2, o3] |
+|              |
+|              |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A045 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c_empty_array_nested, '$') c
+FROM test_json_cols;
++-----------+
+| c         |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+|           |
+|           |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A046 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$') c
+FROM test_json_cols;
++---------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                     |
++---------------------------------------------------------------------------------------------------------------------------------------+
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested, a_obj, a_array] |
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested, a_obj, a_array] |
+| [b_str, b_num_int, b_num_float, b_bool, b_null, b_empty_obj, b_empty_array, b_empty_obj_nested, b_empty_array_nested, b_obj, b_array] |
+| [b_str, b_num_int, b_num_float, b_bool, b_null, b_empty_obj, b_empty_array, b_empty_obj_nested, b_empty_array_nested, b_obj, b_array] |
++---------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A047 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj') c
+FROM test_json_cols;
++---------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                     |
++---------------------------------------------------------------------------------------------------------------------------------------+
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested, a_obj, a_array] |
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested, a_obj, a_array] |
+|                                                                                                                                       |
+|                                                                                                                                       |
++---------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A048 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_str') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A049 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_num_int') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A050 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_num_float') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A051 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_null') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A052 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_empty_obj') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| [] |
+| [] |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A053 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_empty_array') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| [] |
+| [] |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A054 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_empty_obj_nested') c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [o1, o2, o3] |
+| [o1, o2, o3] |
+|              |
+|              |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A055 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_empty_array_nested') c
+FROM test_json_cols;
++-----------+
+| c         |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+|           |
+|           |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A056 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_obj') c
+FROM test_json_cols;
++-----------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                     |
++-----------------------------------------------------------------------------------------------------------------------+
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested] |
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested] |
+|                                                                                                                       |
+|                                                                                                                       |
++-----------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A057 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_array') c
+FROM test_json_cols;
++--------+
+| c      |
++--------+
+| [0, 1] |
+| [0, 1] |
+|        |
+|        |
++--------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A058 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_array[0]') c
+FROM test_json_cols;
++-----------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                     |
++-----------------------------------------------------------------------------------------------------------------------+
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested] |
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested] |
+|                                                                                                                       |
+|                                                                                                                       |
++-----------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A059 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_array[0].a_str') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A060 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_array[0].a_num_int') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A061 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_array[0].a_num_float') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A062 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_array[0].a_null') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A063 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_array[0].a_empty_obj') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| [] |
+| [] |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A064 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_array[0].a_empty_array') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| [] |
+| [] |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A065 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_array[0].a_empty_obj_nested') c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [o1, o2, o3] |
+| [o1, o2, o3] |
+|              |
+|              |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A066 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_array[0].a_empty_array_nested') c
+FROM test_json_cols;
++-----------+
+| c         |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+|           |
+|           |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A067 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array') c
+FROM test_json_cols;
++--------+
+| c      |
++--------+
+| [0, 1] |
+| [0, 1] |
+|        |
+|        |
++--------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A068 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0]') c
+FROM test_json_cols;
++---------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                     |
++---------------------------------------------------------------------------------------------------------------------------------------+
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested, a_obj, a_array] |
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested, a_obj, a_array] |
+|                                                                                                                                       |
+|                                                                                                                                       |
++---------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A069 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0].a_str') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A070 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0].a_num_int') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A071 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0].a_num_float') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A072 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0].a_null') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A073 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0].a_empty_obj') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| [] |
+| [] |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A074 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0].a_empty_array') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| [] |
+| [] |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A075 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0].a_empty_obj_nested') c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [o1, o2, o3] |
+| [o1, o2, o3] |
+|              |
+|              |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A076 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0].a_empty_array_nested') c
+FROM test_json_cols;
++-----------+
+| c         |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+|           |
+|           |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A077 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0].a_obj') c
+FROM test_json_cols;
++-----------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                     |
++-----------------------------------------------------------------------------------------------------------------------+
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested] |
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested] |
+|                                                                                                                       |
+|                                                                                                                       |
++-----------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A078 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0].a_obj.a_str') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A079 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0].a_obj.a_num_int') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A080 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0].a_obj.a_num_float') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A081 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0].a_obj.a_null') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A082 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0].a_obj.a_empty_obj') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| [] |
+| [] |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A083 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0].a_obj.a_empty_array') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| [] |
+| [] |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A084 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0].a_obj.a_empty_obj_nested') c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [o1, o2, o3] |
+| [o1, o2, o3] |
+|              |
+|              |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A085 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[0].a_obj.a_empty_array_nested') c
+FROM test_json_cols;
++-----------+
+| c         |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+|           |
+|           |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A086 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[1].a_array') c
+FROM test_json_cols;
++--------+
+| c      |
++--------+
+| [0, 1] |
+| [0, 1] |
+|        |
+|        |
++--------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A087 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[1].a_array[1]') c
+FROM test_json_cols;
++-----------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                     |
++-----------------------------------------------------------------------------------------------------------------------+
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested] |
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested] |
+|                                                                                                                       |
+|                                                                                                                       |
++-----------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A088 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[1].a_array[1].a_str') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A089 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[1].a_array[1].a_num_int') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A090 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[1].a_array[1].a_num_float') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A091 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[1].a_array[1].a_null') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A092 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[1].a_array[1].a_empty_obj') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| [] |
+| [] |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A093 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[1].a_array[1].a_empty_array') c
+FROM test_json_cols;
++----+
+| c  |
++----+
+| [] |
+| [] |
+|    |
+|    |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A094 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[1].a_array[1].a_empty_obj_nested') c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [o1, o2, o3] |
+| [o1, o2, o3] |
+|              |
+|              |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A095 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_array[1].a_array[1].a_empty_array_nested') c
+FROM test_json_cols;
++-----------+
+| c         |
++-----------+
+| [0, 1, 2] |
+| [0, 1, 2] |
+|           |
+|           |
++-----------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A096 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(c1, '$.a_obj') IS NULL;
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A097 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(c1, '$.a_obj.a_str') IS NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A098 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT json_keys(c1, '$.a_obj')
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A099 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT ALL json_keys(c1, '$.a_array')
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A100 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT json_keys(c1, '$.a_obj.a_str')
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A101 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT ALL json_keys(c1, '$.a_obj.a_num_int')
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A102 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT json_keys(c1, '$') mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A103 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT json_keys(c1, '$.a_obj') mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A104 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT json_keys(c1, '$.a_array') mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A105 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT json_keys(c1, '$.a_array[0]') mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A106 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT json_keys(c1, '$.a_obj.a_str') mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A107 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT json_keys(c1, '$.a_obj.a_num_int') mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A108 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT json_keys(c1, '$.a_obj.a_num_float') mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A109 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT json_keys(c1, '$.a_obj.a_str') mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A110 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT json_keys(c1, '$.a_obj.a_null') mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A111 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT DISTINCT json_keys(c1, '$.a_obj')
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A112 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT DISTINCT json_keys(c1, '$.a_obj.a_str')
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A113 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT DISTINCT json_keys(c1, '$.a_obj.a_num_int')
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A114 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mycol,
+       count(*) c
+FROM
+  (SELECT json_keys(c1, '$.a_obj') mycol
+   FROM test_json_cols)
+GROUP BY mycol;
++---------------------------------------------------------------------------------------------------------------------------------------+---+
+| mycol                                                                                                                                 | c |
++---------------------------------------------------------------------------------------------------------------------------------------+---+
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested, a_obj, a_array] | 2 |
+|                                                                                                                                       | 2 |
++---------------------------------------------------------------------------------------------------------------------------------------+---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A115 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mycol,
+       count(*) c
+FROM
+  (SELECT json_keys(c1, '$.a_obj.a_str') mycol
+   FROM test_json_cols)
+GROUP BY mycol;
++-------+---+
+| mycol | c |
++-------+---+
+|       | 4 |
++-------+---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A116 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mycol,
+       count(*) c
+FROM
+  (SELECT json_keys(c1, '$.a_obj.a_num_int') mycol
+   FROM test_json_cols)
+GROUP BY mycol;
++-------+---+
+| mycol | c |
++-------+---+
+|       | 4 |
++-------+---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A117 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mycol,
+       count(*) c
+FROM
+  (SELECT c1,
+          json_keys(c1, '$.') mycol
+   FROM test_json_cols)
+GROUP BY mycol
+HAVING array_contains(mycol, 'a_str');
++---------------------------------------------------------------------------------------------------------------------------------------+---+
+| mycol                                                                                                                                 | c |
++---------------------------------------------------------------------------------------------------------------------------------------+---+
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested, a_obj, a_array] | 2 |
++---------------------------------------------------------------------------------------------------------------------------------------+---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A118 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mycol,
+       count(*) c
+FROM
+  (SELECT c1,
+          json_keys(c1, '$.') mycol
+   FROM test_json_cols)
+GROUP BY mycol
+HAVING NOT array_contains(mycol, 'a_str');
++---------------------------------------------------------------------------------------------------------------------------------------+---+
+| mycol                                                                                                                                 | c |
++---------------------------------------------------------------------------------------------------------------------------------------+---+
+| [b_str, b_num_int, b_num_float, b_bool, b_null, b_empty_obj, b_empty_array, b_empty_obj_nested, b_empty_array_nested, b_obj, b_array] | 2 |
++---------------------------------------------------------------------------------------------------------------------------------------+---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A119 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(c1, '$.a_obj') = json_keys(c2, '$.a_obj');
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A120 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(c1, '$.a_obj.a_str') = json_keys(c2, '$.a_obj.a_str');
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A121 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_keys(c1, '$.a_obj.a_num_int') = json_keys(c2, '$.a_obj.a_num_int');
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A122 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+INNER JOIN test_json_cols t2 ON json_keys(t1.c1, '$.a_obj')=json_keys(t2.c1, '$.a_obj');
+QueryUnsupportedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A123 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+INNER JOIN test_json_cols t2 ON json_keys(t1.c1, '$.a_obj.a_str')=json_keys(t2.c1, '$.a_obj.a_str');
+QueryUnsupportedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A124 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+INNER JOIN test_json_cols t2 ON json_keys(t1.c1, '$.a_obj.a_num_int')=json_keys(t2.c1, '$.a_obj.a_num_int');
+QueryUnsupportedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A125 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+LEFT JOIN test_json_cols t2 ON json_keys(t1.c1, '$.a_obj')=json_keys(t2.c1, '$.a_obj');
+QueryUnsupportedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A126 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+LEFT JOIN test_json_cols t2 ON json_keys(t1.c1, '$.a_obj.a_str')=json_keys(t2.c1, '$.a_obj.a_str');
+QueryUnsupportedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A127 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+LEFT JOIN test_json_cols t2 ON json_keys(t1.c1, '$.a_obj.a_num_int')=json_keys(t2.c1, '$.a_obj.a_num_int');
+QueryUnsupportedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A128 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1,
+     test_json_cols t2
+WHERE json_keys(t1.c1, '$.a_obj')=json_keys(t2.c1, '$.a_obj');
+QueryUnsupportedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A129 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1,
+     test_json_cols t2
+WHERE json_keys(t1.c1, '$.a_obj.a_str')=json_keys(t2.c1, '$.a_obj.a_str');
+QueryUnsupportedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A130 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1,
+     test_json_cols t2
+WHERE json_keys(t1.c1, '$.a_obj.a_num_int')=json_keys(t2.c1, '$.a_obj.a_num_int');
+QueryUnsupportedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A131 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_array[0]') c
+FROM test_json_cols
+ORDER BY __time;
++-----------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                     |
++-----------------------------------------------------------------------------------------------------------------------+
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested] |
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested] |
+|                                                                                                                       |
+|                                                                                                                       |
++-----------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A132 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_array[0].a_str') c
+FROM test_json_cols
+ORDER BY __time;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A133 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_array[0].a_num_int') c
+FROM test_json_cols
+ORDER BY __time;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
++---+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A134 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj') c
+FROM test_json_cols
+LIMIT 1;
++---------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                     |
++---------------------------------------------------------------------------------------------------------------------------------------+
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested, a_obj, a_array] |
++---------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A135 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_str') c
+FROM test_json_cols
+LIMIT 1;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A136 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_num_int') c
+FROM test_json_cols
+LIMIT 1;
++---+
+| c |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A137 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj') c
+FROM test_json_cols
+OFFSET 1;
++---------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                     |
++---------------------------------------------------------------------------------------------------------------------------------------+
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested, a_obj, a_array] |
+|                                                                                                                                       |
+|                                                                                                                                       |
++---------------------------------------------------------------------------------------------------------------------------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A138 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_str') c
+FROM test_json_cols
+OFFSET 1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A139 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_num_int') c
+FROM test_json_cols
+OFFSET 1;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
++---+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A140 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_array[0]') c
+FROM test_json_cols
+UNION ALL
+SELECT json_keys(c1, '$.a_obj.a_array[0]') c
+FROM test_json_cols;
++-----------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                     |
++-----------------------------------------------------------------------------------------------------------------------+
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested] |
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested] |
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested] |
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested] |
+|                                                                                                                       |
+|                                                                                                                       |
+|                                                                                                                       |
+|                                                                                                                       |
++-----------------------------------------------------------------------------------------------------------------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A141 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_array[0].a_str') c
+FROM test_json_cols
+UNION ALL
+SELECT json_keys(c1, '$.a_obj.a_array[0].a_str') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A142 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_keys(c1, '$.a_obj.a_array[0].a_num_int') c
+FROM test_json_cols
+UNION ALL
+SELECT json_keys(c1, '$.a_obj.a_array[0].a_num_int') c
+FROM test_json_cols;
++---+
+| c |
++---+
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
+|   |
++---+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A143 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_keys(c1, '$.a_obj')
+FROM test_json_cols;
++---------------------------------------------------------------------------------------------------------------------------------------+
+| EXPR$0                                                                                                                                |
++---------------------------------------------------------------------------------------------------------------------------------------+
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested, a_obj, a_array] |
+| [a_str, a_num_int, a_num_float, a_bool, a_null, a_empty_obj, a_empty_array, a_empty_obj_nested, a_empty_array_nested, a_obj, a_array] |
+|                                                                                                                                       |
+|                                                                                                                                       |
++---------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_json_cols"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "expression",
+    "name" : "v0",
+    "expression" : "json_keys(\"c1\",'$.a_obj')",
+    "outputType" : "ARRAY<STRING>"
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "ARRAY<STRING>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A144 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_keys(c1, '$.a_obj.a_str')
+FROM test_json_cols;
++--------+
+| EXPR$0 |
++--------+
+|        |
+|        |
+|        |
+|        |
++--------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_json_cols"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "expression",
+    "name" : "v0",
+    "expression" : "json_keys(\"c1\",'$.a_obj.a_str')",
+    "outputType" : "ARRAY<STRING>"
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "ARRAY<STRING>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_keys TEST_ID: A145 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_keys(c1, '$.a_obj.a_num_int')
+FROM test_json_cols;
++--------+
+| EXPR$0 |
++--------+
+|        |
+|        |
+|        |
+|        |
++--------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_json_cols"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "expression",
+    "name" : "v0",
+    "expression" : "json_keys(\"c1\",'$.a_obj.a_num_int')",
+    "outputType" : "ARRAY<STRING>"
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "ARRAY<STRING>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A001 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(__time) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A002 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_paths(__time) IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A003 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_paths(__time) IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A004 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths('ABCD') c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A005 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_paths('ABCD') IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A006 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_paths('ABCD') IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A007 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(s_str) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A008 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_paths(s_str) IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A009 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_paths(s_str) IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A010 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(1234) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A011 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_paths(1234) IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A012 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_paths(1234) IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A013 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(s_num_int) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A014 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_paths(s_num_int) IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A015 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_paths(s_num_int) IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A016 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(1234.5678) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A017 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_paths(1234.5678) IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A018 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_paths(1234.5678) IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A019 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(s_num_float) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A020 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_paths(s_num_float) IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A021 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_paths(s_num_float) IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A022 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(NULL) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A023 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_paths(NULL) IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A024 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_paths(NULL) IS NOT NULL;
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A025 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(s_str, '$')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A026 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(s_num_int, '$')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A027 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(s_num_float, '$')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A028 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(s_null, '$')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A029 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c_empty_obj, '$')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A030 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c_empty_array, '$')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A031 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c_empty_obj_nested, '$')) c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [$.o2, $.o3] |
+| [$.o2, $.o3] |
+| [$]          |
+| [$]          |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A032 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c_empty_array_nested, '$')) c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [$[2], $[1]] |
+| [$[2], $[1]] |
+| [$]          |
+| [$]          |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A033 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_paths(c1)) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| 130 |
+| 130 |
+| 130 |
+| 130 |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A034 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_paths(json_query(c1, '$.a_obj'))) c
+FROM test_json_cols;
++----+
+| c  |
++----+
+|  1 |
+|  1 |
+| 40 |
+| 40 |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A035 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_str')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A036 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_num_int')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A037 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_num_float')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A038 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_null')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A039 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_empty_obj')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A040 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_empty_array')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A041 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_empty_obj_nested')) c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [$.o2, $.o3] |
+| [$.o2, $.o3] |
+| [$]          |
+| [$]          |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A042 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_empty_array_nested')) c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [$[2], $[1]] |
+| [$[2], $[1]] |
+| [$]          |
+| [$]          |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A043 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_obj')) c
+FROM test_json_cols;
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                  |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [$.a_str, $.a_empty_array, $.a_null, $.a_num_int, $.a_bool, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_empty_obj_nested.o2, $.a_num_float, $.a_empty_obj_nested.o3] |
+| [$.a_str, $.a_empty_array, $.a_null, $.a_num_int, $.a_bool, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_empty_obj_nested.o2, $.a_num_float, $.a_empty_obj_nested.o3] |
+| [$]                                                                                                                                                                                |
+| [$]                                                                                                                                                                                |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A044 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_array')) c
+FROM test_json_cols;
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                                                                                                                                                                                                                                                |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [$[0].a_bool, $[1].a_num_int, $[0].a_num_int, $[1].a_bool, $[1].a_num_float, $[0].a_num_float, $[1].a_empty_array, $[0].a_empty_array, $[1].a_str, $[1].a_null, $[0].a_null, $[0].a_str, $[1].a_empty_array_nested[2], $[0].a_empty_obj_nested.o3, $[1].a_empty_obj_nested.o2, $[0].a_empty_obj_nested.o2, $[1].a_empty_obj_nested.o3, $[0].a_empty_array_nested[2], $[1].a_empty_array_nested[1], $[0].a_empty_array_nested[1]] |
+| [$[0].a_bool, $[1].a_num_int, $[0].a_num_int, $[1].a_bool, $[1].a_num_float, $[0].a_num_float, $[1].a_empty_array, $[0].a_empty_array, $[1].a_str, $[1].a_null, $[0].a_null, $[0].a_str, $[1].a_empty_array_nested[2], $[0].a_empty_obj_nested.o3, $[1].a_empty_obj_nested.o2, $[0].a_empty_obj_nested.o2, $[1].a_empty_obj_nested.o3, $[0].a_empty_array_nested[2], $[1].a_empty_array_nested[1], $[0].a_empty_array_nested[1]] |
+| [$]                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| [$]                                                                                                                                                                                                                                                                                                                                                                                                                              |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A045 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_array[0]')) c
+FROM test_json_cols;
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                  |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [$.a_str, $.a_empty_array, $.a_null, $.a_num_int, $.a_bool, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_empty_obj_nested.o2, $.a_num_float, $.a_empty_obj_nested.o3] |
+| [$.a_str, $.a_empty_array, $.a_null, $.a_num_int, $.a_bool, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_empty_obj_nested.o2, $.a_num_float, $.a_empty_obj_nested.o3] |
+| [$]                                                                                                                                                                                |
+| [$]                                                                                                                                                                                |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A046 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_array[0].a_str')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A047 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_array[0].a_num_int')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A048 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_array[0].a_num_float')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A049 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_array[0].a_null')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A050 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_array[0].a_empty_obj')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A051 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_array[0].a_empty_array')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A052 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_array[0].a_empty_obj_nested')) c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [$.o2, $.o3] |
+| [$.o2, $.o3] |
+| [$]          |
+| [$]          |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A053 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_array[0].a_empty_array_nested')) c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [$[2], $[1]] |
+| [$[2], $[1]] |
+| [$]          |
+| [$]          |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A054 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_paths(json_query(c1, '$.a_array'))) c
+FROM test_json_cols;
++----+
+| c  |
++----+
+|  1 |
+|  1 |
+| 80 |
+| 80 |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A055 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT array_length(json_paths(json_query(c1, '$.a_array[0]'))) c
+FROM test_json_cols;
++----+
+| c  |
++----+
+|  1 |
+|  1 |
+| 40 |
+| 40 |
++----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A056 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[0].a_str')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A057 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[0].a_num_int')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A058 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[0].a_num_float')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A059 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[0].a_null')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A060 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[0].a_empty_obj')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A061 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[0].a_empty_array')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A062 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[0].a_empty_obj_nested')) c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [$.o2, $.o3] |
+| [$.o2, $.o3] |
+| [$]          |
+| [$]          |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A063 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[0].a_empty_array_nested')) c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [$[2], $[1]] |
+| [$[2], $[1]] |
+| [$]          |
+| [$]          |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A064 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[0].a_obj')) c
+FROM test_json_cols;
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                  |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [$.a_str, $.a_empty_array, $.a_null, $.a_num_int, $.a_bool, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_empty_obj_nested.o2, $.a_num_float, $.a_empty_obj_nested.o3] |
+| [$.a_str, $.a_empty_array, $.a_null, $.a_num_int, $.a_bool, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_empty_obj_nested.o2, $.a_num_float, $.a_empty_obj_nested.o3] |
+| [$]                                                                                                                                                                                |
+| [$]                                                                                                                                                                                |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A065 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[0].a_obj.a_str')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A066 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[0].a_obj.a_num_int')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A067 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[0].a_obj.a_num_float')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A068 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[0].a_obj.a_null')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A069 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[0].a_obj.a_empty_obj')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A070 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[0].a_obj.a_empty_array')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A071 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[0].a_obj.a_empty_obj_nested')) c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [$.o2, $.o3] |
+| [$.o2, $.o3] |
+| [$]          |
+| [$]          |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A072 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[0].a_obj.a_empty_array_nested')) c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [$[2], $[1]] |
+| [$[2], $[1]] |
+| [$]          |
+| [$]          |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A073 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[1].a_array')) c
+FROM test_json_cols;
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                                                                                                                                                                                                                                                |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [$[0].a_bool, $[1].a_num_int, $[0].a_num_int, $[1].a_bool, $[1].a_num_float, $[0].a_num_float, $[1].a_empty_array, $[0].a_empty_array, $[1].a_str, $[1].a_null, $[0].a_null, $[0].a_str, $[1].a_empty_array_nested[2], $[0].a_empty_obj_nested.o3, $[1].a_empty_obj_nested.o2, $[0].a_empty_obj_nested.o2, $[1].a_empty_obj_nested.o3, $[0].a_empty_array_nested[2], $[1].a_empty_array_nested[1], $[0].a_empty_array_nested[1]] |
+| [$[0].a_bool, $[1].a_num_int, $[0].a_num_int, $[1].a_bool, $[1].a_num_float, $[0].a_num_float, $[1].a_empty_array, $[0].a_empty_array, $[1].a_str, $[1].a_null, $[0].a_null, $[0].a_str, $[1].a_empty_array_nested[2], $[0].a_empty_obj_nested.o3, $[1].a_empty_obj_nested.o2, $[0].a_empty_obj_nested.o2, $[1].a_empty_obj_nested.o3, $[0].a_empty_array_nested[2], $[1].a_empty_array_nested[1], $[0].a_empty_array_nested[1]] |
+| [$]                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| [$]                                                                                                                                                                                                                                                                                                                                                                                                                              |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A074 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[1].a_array[1]')) c
+FROM test_json_cols;
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                  |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [$.a_str, $.a_empty_array, $.a_null, $.a_num_int, $.a_bool, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_empty_obj_nested.o2, $.a_num_float, $.a_empty_obj_nested.o3] |
+| [$.a_str, $.a_empty_array, $.a_null, $.a_num_int, $.a_bool, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_empty_obj_nested.o2, $.a_num_float, $.a_empty_obj_nested.o3] |
+| [$]                                                                                                                                                                                |
+| [$]                                                                                                                                                                                |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A075 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[1].a_array[1].a_str')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A076 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[1].a_array[1].a_num_int')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A077 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[1].a_array[1].a_num_float')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A078 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[1].a_array[1].a_null')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A079 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[1].a_array[1].a_empty_obj')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| []  |
+| []  |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A080 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[1].a_array[1].a_empty_array')) c
+FROM test_json_cols;
++-----+
+| c   |
++-----+
+| [$] |
+| [$] |
+| [$] |
+| [$] |
++-----+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A081 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[1].a_array[1].a_empty_obj_nested')) c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [$.o2, $.o3] |
+| [$.o2, $.o3] |
+| [$]          |
+| [$]          |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A082 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_array[1].a_array[1].a_empty_array_nested')) c
+FROM test_json_cols;
++--------------+
+| c            |
++--------------+
+| [$[2], $[1]] |
+| [$[2], $[1]] |
+| [$]          |
+| [$]          |
++--------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A083 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_paths(c1) IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A084 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_paths(c1) IS NULL;
++---+
+| c |
++---+
+| 0 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A085 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT json_paths(c1)
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A086 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT ALL json_paths(c1)
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A087 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT json_paths(c1) mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A088 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(mycol) c
+FROM
+  (SELECT json_paths(c1) mycol
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A089 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM
+  (SELECT DISTINCT json_paths(c1)
+   FROM test_json_cols);
++---+
+| c |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A090 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mycol,
+       count(*) c
+FROM
+  (SELECT json_paths(json_query(c1, '$.a_obj.a_obj')) mycol
+   FROM test_json_cols)
+GROUP BY mycol;
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---+
+| mycol                                                                                                                                                                              | c |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---+
+| [$.a_str, $.a_empty_array, $.a_null, $.a_num_int, $.a_bool, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_empty_obj_nested.o2, $.a_num_float, $.a_empty_obj_nested.o3] | 2 |
+| [$]                                                                                                                                                                                | 2 |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---+
+(2 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A091 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT mycol,
+       count(*) c
+FROM
+  (SELECT c1,
+          json_paths(json_query(c1, '$.a_obj.a_obj')) mycol
+   FROM test_json_cols)
+GROUP BY mycol
+HAVING array_contains(mycol, '$.a_str');
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---+
+| mycol                                                                                                                                                                              | c |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---+
+| [$.a_str, $.a_empty_array, $.a_null, $.a_num_int, $.a_bool, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_empty_obj_nested.o2, $.a_num_float, $.a_empty_obj_nested.o3] | 2 |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A092 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols
+WHERE json_paths(c1) = json_paths(c2);
++---+
+| c |
++---+
+| 4 |
++---+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A093 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+INNER JOIN test_json_cols t2 ON json_paths(t1.c1)=json_paths(t2.c1);
+QueryUnsupportedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A094 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1
+LEFT JOIN test_json_cols t2 ON json_paths(t1.c1)=json_paths(t2.c1);
+QueryUnsupportedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A095 TYPE: NEGATIVE TEST
+#-------------------------------------------------------------------------
+SELECT count(*) c
+FROM test_json_cols t1,
+     test_json_cols t2
+WHERE json_paths(t1.c1)=json_paths(t2.c1);
+QueryUnsupportedException
+!error
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A096 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_obj')) c
+FROM test_json_cols
+ORDER BY __time;
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                  |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [$.a_str, $.a_empty_array, $.a_null, $.a_num_int, $.a_bool, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_empty_obj_nested.o2, $.a_num_float, $.a_empty_obj_nested.o3] |
+| [$.a_str, $.a_empty_array, $.a_null, $.a_num_int, $.a_bool, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_empty_obj_nested.o2, $.a_num_float, $.a_empty_obj_nested.o3] |
+| [$]                                                                                                                                                                                |
+| [$]                                                                                                                                                                                |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A097 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(c1) c
+FROM test_json_cols
+LIMIT 1;
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [$.a_array[1].a_array[1].a_str, $.a_obj.a_obj.a_bool, $.a_array[1].a_array[0].a_empty_obj_nested.o2, $.a_array[1].a_array[0].a_empty_obj_nested.o3, $.a_obj.a_array[0].a_num_float, $.a_array[1].a_array[0].a_empty_array_nested[1], $.a_array[1].a_array[0].a_empty_array_nested[2], $.a_obj.a_array[0].a_str, $.a_obj.a_array[1].a_null, $.a_str, $.a_array[0].a_obj.a_num_float, $.a_null, $.a_array[0].a_str, $.a_array[1].a_num_float, $.a_array[1].a_array[1].a_num_float, $.a_array[1].a_obj.a_bool, $.a_array[1].a_array[1].a_null, $.a_obj.a_array[1].a_num_float, $.a_array[1].a_num_int, $.a_num_int, $.a_array[0].a_empty_array_nested[2], $.a_array[0].a_empty_array_nested[1], $.a_array[0].a_array[1].a_bool, $.a_obj.a_array[1].a_str, $.a_array[1].a_null, $.a_array[0].a_empty_obj_nested.o2, $.a_array[0].a_empty_obj_nested.o3, $.a_array[1].a_array[0].a_num_float, $.a_array[0].a_num_float, $.a_array[0].a_array[0].a_empty_array, $.a_array[1].a_empty_array, $.a_array[1].a_obj.a_str, $.a_array[0].a_obj.a_num_int, $.a_array[0].a_obj.a_null, $.a_array[1].a_array[1].a_empty_obj_nested.o3, $.a_obj.a_obj.a_num_float, $.a_array[0].a_num_int, $.a_array[0].a_bool, $.a_array[1].a_array[1].a_empty_obj_nested.o2, $.a_obj.a_array[0].a_num_int, $.a_obj.a_array[0].a_bool, $.a_array[1].a_array[1].a_num_int, $.a_array[0].a_array[0].a_bool, $.a_array[1].a_array[0].a_null, $.a_array[0].a_obj.a_empty_obj_nested.o2, $.a_array[0].a_obj.a_empty_obj_nested.o3, $.a_obj.a_bool, $.a_array[1].a_obj.a_num_float, $.a_obj.a_array[1].a_empty_obj_nested.o3, $.a_array[0].a_array[1].a_empty_array, $.a_obj.a_array[1].a_empty_obj_nested.o2, $.a_array[0].a_obj.a_bool, $.a_obj.a_array[1].a_num_int, $.a_obj.a_array[1].a_bool, $.a_num_float, $.a_array[1].a_str, $.a_array[1].a_empty_obj_nested.o3, $.a_array[1].a_empty_obj_nested.o2, $.a_obj.a_obj.a_empty_array_nested[1], $.a_obj.a_obj.a_empty_array_nested[2], $.a_array[0].a_array[1].a_empty_array_nested[1], $.a_array[0].a_obj.a_str, $.a_array[0].a_array[1].a_empty_array_nested[2], $.a_array[1].a_obj.a_num_int, $.a_obj.a_obj.a_num_int, $.a_array[0].a_array[0].a_str, $.a_obj.a_str, $.a_array[0].a_array[0].a_empty_array_nested[1], $.a_array[0].a_array[0].a_empty_obj_nested.o2, $.a_array[1].a_obj.a_empty_array, $.a_array[0].a_array[1].a_null, $.a_obj.a_num_float, $.a_array[0].a_array[0].a_num_float, $.a_obj.a_obj.a_empty_array, $.a_obj.a_array[0].a_empty_obj_nested.o2, $.a_obj.a_array[0].a_empty_obj_nested.o3, $.a_array[1].a_array[0].a_empty_array, $.a_obj.a_array[0].a_empty_array_nested[1], $.a_obj.a_array[0].a_empty_array_nested[2], $.a_obj.a_empty_obj_nested.o3, $.a_array[0].a_array[1].a_str, $.a_obj.a_null, $.a_array[1].a_bool, $.a_obj.a_empty_obj_nested.o2, $.a_bool, $.a_array[1].a_array[0].a_num_int, $.a_obj.a_obj.a_null, $.a_array[0].a_array[0].a_null, $.a_array[1].a_obj.a_empty_obj_nested.o3, $.a_obj.a_num_int, $.a_array[1].a_obj.a_empty_obj_nested.o2, $.a_array[0].a_array[0].a_empty_obj_nested.o3, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_obj.a_empty_array_nested[1], $.a_obj.a_empty_array_nested[2], $.a_array[1].a_obj.a_empty_array_nested[2], $.a_array[0].a_array[0].a_empty_array_nested[2], $.a_array[1].a_array[1].a_empty_array, $.a_empty_obj_nested.o2, $.a_empty_obj_nested.o3, $.a_array[1].a_obj.a_empty_array_nested[1], $.a_empty_array, $.a_array[0].a_obj.a_empty_array, $.a_array[1].a_array[1].a_empty_array_nested[2], $.a_obj.a_empty_array, $.a_array[1].a_array[1].a_bool, $.a_array[1].a_array[1].a_empty_array_nested[1], $.a_array[0].a_array[0].a_num_int, $.a_obj.a_obj.a_str, $.a_array[0].a_null, $.a_obj.a_array[0].a_empty_array, $.a_obj.a_array[1].a_empty_array_nested[2], $.a_array[0].a_obj.a_empty_array_nested[1], $.a_array[0].a_obj.a_empty_array_nested[2], $.a_array[0].a_empty_array, $.a_obj.a_array[1].a_empty_array_nested[1], $.a_obj.a_array[0].a_null, $.a_array[1].a_array[0].a_str, $.a_array[1].a_empty_array_nested[1], $.a_array[1].a_array[0].a_bool, $.a_array[0].a_array[1].a_num_int, $.a_array[1].a_empty_array_nested[2], $.a_obj.a_array[1].a_empty_array, $.a_array[0].a_array[1].a_num_float, $.a_array[0].a_array[1].a_empty_obj_nested.o2, $.a_array[0].a_array[1].a_empty_obj_nested.o3, $.a_obj.a_obj.a_empty_obj_nested.o2, $.a_array[1].a_obj.a_null, $.a_obj.a_obj.a_empty_obj_nested.o3] |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(1 row)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A098 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(c1) c
+FROM test_json_cols
+OFFSET 1;
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [$.a_array[1].a_array[1].a_str, $.a_obj.a_obj.a_bool, $.a_array[1].a_array[0].a_empty_obj_nested.o2, $.a_array[1].a_array[0].a_empty_obj_nested.o3, $.a_obj.a_array[0].a_num_float, $.a_array[1].a_array[0].a_empty_array_nested[1], $.a_array[1].a_array[0].a_empty_array_nested[2], $.a_obj.a_array[0].a_str, $.a_obj.a_array[1].a_null, $.a_str, $.a_array[0].a_obj.a_num_float, $.a_null, $.a_array[0].a_str, $.a_array[1].a_num_float, $.a_array[1].a_array[1].a_num_float, $.a_array[1].a_obj.a_bool, $.a_array[1].a_array[1].a_null, $.a_obj.a_array[1].a_num_float, $.a_array[1].a_num_int, $.a_num_int, $.a_array[0].a_empty_array_nested[2], $.a_array[0].a_empty_array_nested[1], $.a_array[0].a_array[1].a_bool, $.a_obj.a_array[1].a_str, $.a_array[1].a_null, $.a_array[0].a_empty_obj_nested.o2, $.a_array[0].a_empty_obj_nested.o3, $.a_array[1].a_array[0].a_num_float, $.a_array[0].a_num_float, $.a_array[0].a_array[0].a_empty_array, $.a_array[1].a_empty_array, $.a_array[1].a_obj.a_str, $.a_array[0].a_obj.a_num_int, $.a_array[0].a_obj.a_null, $.a_array[1].a_array[1].a_empty_obj_nested.o3, $.a_obj.a_obj.a_num_float, $.a_array[0].a_num_int, $.a_array[0].a_bool, $.a_array[1].a_array[1].a_empty_obj_nested.o2, $.a_obj.a_array[0].a_num_int, $.a_obj.a_array[0].a_bool, $.a_array[1].a_array[1].a_num_int, $.a_array[0].a_array[0].a_bool, $.a_array[1].a_array[0].a_null, $.a_array[0].a_obj.a_empty_obj_nested.o2, $.a_array[0].a_obj.a_empty_obj_nested.o3, $.a_obj.a_bool, $.a_array[1].a_obj.a_num_float, $.a_obj.a_array[1].a_empty_obj_nested.o3, $.a_array[0].a_array[1].a_empty_array, $.a_obj.a_array[1].a_empty_obj_nested.o2, $.a_array[0].a_obj.a_bool, $.a_obj.a_array[1].a_num_int, $.a_obj.a_array[1].a_bool, $.a_num_float, $.a_array[1].a_str, $.a_array[1].a_empty_obj_nested.o3, $.a_array[1].a_empty_obj_nested.o2, $.a_obj.a_obj.a_empty_array_nested[1], $.a_obj.a_obj.a_empty_array_nested[2], $.a_array[0].a_array[1].a_empty_array_nested[1], $.a_array[0].a_obj.a_str, $.a_array[0].a_array[1].a_empty_array_nested[2], $.a_array[1].a_obj.a_num_int, $.a_obj.a_obj.a_num_int, $.a_array[0].a_array[0].a_str, $.a_obj.a_str, $.a_array[0].a_array[0].a_empty_array_nested[1], $.a_array[0].a_array[0].a_empty_obj_nested.o2, $.a_array[1].a_obj.a_empty_array, $.a_array[0].a_array[1].a_null, $.a_obj.a_num_float, $.a_array[0].a_array[0].a_num_float, $.a_obj.a_obj.a_empty_array, $.a_obj.a_array[0].a_empty_obj_nested.o2, $.a_obj.a_array[0].a_empty_obj_nested.o3, $.a_array[1].a_array[0].a_empty_array, $.a_obj.a_array[0].a_empty_array_nested[1], $.a_obj.a_array[0].a_empty_array_nested[2], $.a_obj.a_empty_obj_nested.o3, $.a_array[0].a_array[1].a_str, $.a_obj.a_null, $.a_array[1].a_bool, $.a_obj.a_empty_obj_nested.o2, $.a_bool, $.a_array[1].a_array[0].a_num_int, $.a_obj.a_obj.a_null, $.a_array[0].a_array[0].a_null, $.a_array[1].a_obj.a_empty_obj_nested.o3, $.a_obj.a_num_int, $.a_array[1].a_obj.a_empty_obj_nested.o2, $.a_array[0].a_array[0].a_empty_obj_nested.o3, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_obj.a_empty_array_nested[1], $.a_obj.a_empty_array_nested[2], $.a_array[1].a_obj.a_empty_array_nested[2], $.a_array[0].a_array[0].a_empty_array_nested[2], $.a_array[1].a_array[1].a_empty_array, $.a_empty_obj_nested.o2, $.a_empty_obj_nested.o3, $.a_array[1].a_obj.a_empty_array_nested[1], $.a_empty_array, $.a_array[0].a_obj.a_empty_array, $.a_array[1].a_array[1].a_empty_array_nested[2], $.a_obj.a_empty_array, $.a_array[1].a_array[1].a_bool, $.a_array[1].a_array[1].a_empty_array_nested[1], $.a_array[0].a_array[0].a_num_int, $.a_obj.a_obj.a_str, $.a_array[0].a_null, $.a_obj.a_array[0].a_empty_array, $.a_obj.a_array[1].a_empty_array_nested[2], $.a_array[0].a_obj.a_empty_array_nested[1], $.a_array[0].a_obj.a_empty_array_nested[2], $.a_array[0].a_empty_array, $.a_obj.a_array[1].a_empty_array_nested[1], $.a_obj.a_array[0].a_null, $.a_array[1].a_array[0].a_str, $.a_array[1].a_empty_array_nested[1], $.a_array[1].a_array[0].a_bool, $.a_array[0].a_array[1].a_num_int, $.a_array[1].a_empty_array_nested[2], $.a_obj.a_array[1].a_empty_array, $.a_array[0].a_array[1].a_num_float, $.a_array[0].a_array[1].a_empty_obj_nested.o2, $.a_array[0].a_array[1].a_empty_obj_nested.o3, $.a_obj.a_obj.a_empty_obj_nested.o2, $.a_array[1].a_obj.a_null, $.a_obj.a_obj.a_empty_obj_nested.o3] |
+| [$.b_array[1].b_bool, $.b_array[1].b_array[0].b_num_int, $.b_array[0].b_array[0].b_num_float, $.b_obj.b_array[0].b_empty_array_nested[1], $.b_obj.b_array[0].b_empty_array_nested[2], $.b_array[0].b_obj.b_bool, $.b_array[1].b_obj.b_str, $.b_obj.b_num_int, $.b_array[0].b_array[1].b_null, $.b_obj.b_array[0].b_bool, $.b_array[1].b_array[0].b_str, $.b_num_float, $.b_array[0].b_array[1].b_empty_obj_nested.o3, $.b_obj.b_str, $.b_array[0].b_str, $.b_array[0].b_bool, $.b_array[0].b_array[1].b_empty_obj_nested.o2, $.b_null, $.b_obj.b_obj.b_empty_obj_nested.o3, $.b_obj.b_obj.b_empty_obj_nested.o2, $.b_array[0].b_array[1].b_empty_array, $.b_array[0].b_array[0].b_empty_array_nested[1], $.b_array[0].b_array[0].b_empty_array_nested[2], $.b_obj.b_empty_obj_nested.o2, $.b_obj.b_array[1].b_empty_obj_nested.o2, $.b_obj.b_array[1].b_empty_obj_nested.o3, $.b_array[0].b_array[0].b_empty_array, $.b_obj.b_empty_obj_nested.o3, $.b_array[0].b_obj.b_str, $.b_obj.b_array[1].b_bool, $.b_obj.b_array[0].b_str, $.b_obj.b_array[0].b_num_int, $.b_array[1].b_str, $.b_obj.b_array[1].b_num_float, $.b_bool, $.b_array[1].b_obj.b_bool, $.b_array[1].b_obj.b_empty_array, $.b_array[1].b_array[1].b_empty_array, $.b_empty_array_nested[2], $.b_empty_array_nested[1], $.b_array[1].b_array[1].b_bool, $.b_array[0].b_empty_obj_nested.o2, $.b_array[0].b_empty_obj_nested.o3, $.b_array[1].b_array[1].b_empty_array_nested[1], $.b_array[1].b_array[1].b_empty_array_nested[2], $.b_obj.b_empty_array, $.b_array[0].b_empty_array, $.b_obj.b_obj.b_num_float, $.b_array[1].b_array[1].b_num_int, $.b_obj.b_array[1].b_null, $.b_array[0].b_array[1].b_num_float, $.b_array[1].b_empty_array_nested[1], $.b_array[1].b_array[1].b_empty_obj_nested.o3, $.b_array[1].b_array[1].b_empty_obj_nested.o2, $.b_array[1].b_array[0].b_empty_array, $.b_array[0].b_array[0].b_null, $.b_array[1].b_empty_array_nested[2], $.b_array[1].b_array[1].b_str, $.b_obj.b_obj.b_empty_array_nested[2], $.b_obj.b_obj.b_empty_array_nested[1], $.b_obj.b_obj.b_null, $.b_array[1].b_obj.b_num_int, $.b_obj.b_obj.b_num_int, $.b_array[0].b_obj.b_empty_obj_nested.o3, $.b_array[0].b_obj.b_empty_obj_nested.o2, $.b_str, $.b_empty_obj_nested.o2, $.b_obj.b_array[0].b_null, $.b_empty_obj_nested.o3, $.b_array[1].b_empty_array, $.b_array[1].b_array[1].b_num_float, $.b_array[0].b_obj.b_empty_array, $.b_obj.b_array[1].b_empty_array, $.b_array[0].b_obj.b_null, $.b_num_int, $.b_array[1].b_array[0].b_empty_obj_nested.o2, $.b_array[1].b_null, $.b_array[1].b_empty_obj_nested.o2, $.b_array[1].b_empty_obj_nested.o3, $.b_array[1].b_array[0].b_empty_array_nested[2], $.b_array[1].b_array[0].b_empty_array_nested[1], $.b_obj.b_bool, $.b_obj.b_array[0].b_num_float, $.b_obj.b_array[1].b_num_int, $.b_array[1].b_array[0].b_num_float, $.b_array[0].b_empty_array_nested[2], $.b_array[0].b_empty_array_nested[1], $.b_array[1].b_array[0].b_empty_obj_nested.o3, $.b_array[1].b_num_int, $.b_array[0].b_num_float, $.b_array[1].b_num_float, $.b_array[1].b_array[0].b_bool, $.b_array[0].b_obj.b_empty_array_nested[2], $.b_obj.b_num_float, $.b_array[0].b_obj.b_empty_array_nested[1], $.b_array[0].b_obj.b_num_float, $.b_array[0].b_null, $.b_array[0].b_obj.b_num_int, $.b_empty_array, $.b_array[0].b_array[1].b_num_int, $.b_obj.b_array[1].b_empty_array_nested[2], $.b_obj.b_array[1].b_empty_array_nested[1], $.b_array[0].b_num_int, $.b_array[1].b_array[0].b_null, $.b_array[1].b_obj.b_null, $.b_array[0].b_array[1].b_empty_array_nested[2], $.b_obj.b_obj.b_bool, $.b_array[0].b_array[0].b_bool, $.b_obj.b_obj.b_empty_array, $.b_array[0].b_array[1].b_str, $.b_array[1].b_obj.b_empty_array_nested[1], $.b_array[1].b_obj.b_empty_array_nested[2], $.b_obj.b_null, $.b_obj.b_array[1].b_str, $.b_obj.b_empty_array_nested[2], $.b_array[0].b_array[0].b_num_int, $.b_obj.b_empty_array_nested[1], $.b_array[1].b_obj.b_empty_obj_nested.o3, $.b_array[0].b_array[0].b_empty_obj_nested.o3, $.b_array[1].b_obj.b_empty_obj_nested.o2, $.b_array[0].b_array[0].b_empty_obj_nested.o2, $.b_array[1].b_array[1].b_null, $.b_obj.b_array[0].b_empty_array, $.b_array[0].b_array[1].b_empty_array_nested[1], $.b_obj.b_array[0].b_empty_obj_nested.o3, $.b_array[0].b_array[1].b_bool, $.b_obj.b_array[0].b_empty_obj_nested.o2, $.b_array[0].b_array[0].b_str, $.b_obj.b_obj.b_str, $.b_array[1].b_obj.b_num_float] |
+| [$.b_array[1].b_bool, $.b_array[1].b_array[0].b_num_int, $.b_array[0].b_array[0].b_num_float, $.b_obj.b_array[0].b_empty_array_nested[1], $.b_obj.b_array[0].b_empty_array_nested[2], $.b_array[0].b_obj.b_bool, $.b_array[1].b_obj.b_str, $.b_obj.b_num_int, $.b_array[0].b_array[1].b_null, $.b_obj.b_array[0].b_bool, $.b_array[1].b_array[0].b_str, $.b_num_float, $.b_array[0].b_array[1].b_empty_obj_nested.o3, $.b_obj.b_str, $.b_array[0].b_str, $.b_array[0].b_bool, $.b_array[0].b_array[1].b_empty_obj_nested.o2, $.b_null, $.b_obj.b_obj.b_empty_obj_nested.o3, $.b_obj.b_obj.b_empty_obj_nested.o2, $.b_array[0].b_array[1].b_empty_array, $.b_array[0].b_array[0].b_empty_array_nested[1], $.b_array[0].b_array[0].b_empty_array_nested[2], $.b_obj.b_empty_obj_nested.o2, $.b_obj.b_array[1].b_empty_obj_nested.o2, $.b_obj.b_array[1].b_empty_obj_nested.o3, $.b_array[0].b_array[0].b_empty_array, $.b_obj.b_empty_obj_nested.o3, $.b_array[0].b_obj.b_str, $.b_obj.b_array[1].b_bool, $.b_obj.b_array[0].b_str, $.b_obj.b_array[0].b_num_int, $.b_array[1].b_str, $.b_obj.b_array[1].b_num_float, $.b_bool, $.b_array[1].b_obj.b_bool, $.b_array[1].b_obj.b_empty_array, $.b_array[1].b_array[1].b_empty_array, $.b_empty_array_nested[2], $.b_empty_array_nested[1], $.b_array[1].b_array[1].b_bool, $.b_array[0].b_empty_obj_nested.o2, $.b_array[0].b_empty_obj_nested.o3, $.b_array[1].b_array[1].b_empty_array_nested[1], $.b_array[1].b_array[1].b_empty_array_nested[2], $.b_obj.b_empty_array, $.b_array[0].b_empty_array, $.b_obj.b_obj.b_num_float, $.b_array[1].b_array[1].b_num_int, $.b_obj.b_array[1].b_null, $.b_array[0].b_array[1].b_num_float, $.b_array[1].b_empty_array_nested[1], $.b_array[1].b_array[1].b_empty_obj_nested.o3, $.b_array[1].b_array[1].b_empty_obj_nested.o2, $.b_array[1].b_array[0].b_empty_array, $.b_array[0].b_array[0].b_null, $.b_array[1].b_empty_array_nested[2], $.b_array[1].b_array[1].b_str, $.b_obj.b_obj.b_empty_array_nested[2], $.b_obj.b_obj.b_empty_array_nested[1], $.b_obj.b_obj.b_null, $.b_array[1].b_obj.b_num_int, $.b_obj.b_obj.b_num_int, $.b_array[0].b_obj.b_empty_obj_nested.o3, $.b_array[0].b_obj.b_empty_obj_nested.o2, $.b_str, $.b_empty_obj_nested.o2, $.b_obj.b_array[0].b_null, $.b_empty_obj_nested.o3, $.b_array[1].b_empty_array, $.b_array[1].b_array[1].b_num_float, $.b_array[0].b_obj.b_empty_array, $.b_obj.b_array[1].b_empty_array, $.b_array[0].b_obj.b_null, $.b_num_int, $.b_array[1].b_array[0].b_empty_obj_nested.o2, $.b_array[1].b_null, $.b_array[1].b_empty_obj_nested.o2, $.b_array[1].b_empty_obj_nested.o3, $.b_array[1].b_array[0].b_empty_array_nested[2], $.b_array[1].b_array[0].b_empty_array_nested[1], $.b_obj.b_bool, $.b_obj.b_array[0].b_num_float, $.b_obj.b_array[1].b_num_int, $.b_array[1].b_array[0].b_num_float, $.b_array[0].b_empty_array_nested[2], $.b_array[0].b_empty_array_nested[1], $.b_array[1].b_array[0].b_empty_obj_nested.o3, $.b_array[1].b_num_int, $.b_array[0].b_num_float, $.b_array[1].b_num_float, $.b_array[1].b_array[0].b_bool, $.b_array[0].b_obj.b_empty_array_nested[2], $.b_obj.b_num_float, $.b_array[0].b_obj.b_empty_array_nested[1], $.b_array[0].b_obj.b_num_float, $.b_array[0].b_null, $.b_array[0].b_obj.b_num_int, $.b_empty_array, $.b_array[0].b_array[1].b_num_int, $.b_obj.b_array[1].b_empty_array_nested[2], $.b_obj.b_array[1].b_empty_array_nested[1], $.b_array[0].b_num_int, $.b_array[1].b_array[0].b_null, $.b_array[1].b_obj.b_null, $.b_array[0].b_array[1].b_empty_array_nested[2], $.b_obj.b_obj.b_bool, $.b_array[0].b_array[0].b_bool, $.b_obj.b_obj.b_empty_array, $.b_array[0].b_array[1].b_str, $.b_array[1].b_obj.b_empty_array_nested[1], $.b_array[1].b_obj.b_empty_array_nested[2], $.b_obj.b_null, $.b_obj.b_array[1].b_str, $.b_obj.b_empty_array_nested[2], $.b_array[0].b_array[0].b_num_int, $.b_obj.b_empty_array_nested[1], $.b_array[1].b_obj.b_empty_obj_nested.o3, $.b_array[0].b_array[0].b_empty_obj_nested.o3, $.b_array[1].b_obj.b_empty_obj_nested.o2, $.b_array[0].b_array[0].b_empty_obj_nested.o2, $.b_array[1].b_array[1].b_null, $.b_obj.b_array[0].b_empty_array, $.b_array[0].b_array[1].b_empty_array_nested[1], $.b_obj.b_array[0].b_empty_obj_nested.o3, $.b_array[0].b_array[1].b_bool, $.b_obj.b_array[0].b_empty_obj_nested.o2, $.b_array[0].b_array[0].b_str, $.b_obj.b_obj.b_str, $.b_array[1].b_obj.b_num_float] |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(3 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A099 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+SELECT json_paths(json_query(c1, '$.a_obj.a_obj')) c
+FROM test_json_cols
+UNION ALL
+SELECT json_paths(json_query(c1, '$.a_obj.a_obj')) c
+FROM test_json_cols;
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| c                                                                                                                                                                                  |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [$.a_str, $.a_empty_array, $.a_null, $.a_num_int, $.a_bool, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_empty_obj_nested.o2, $.a_num_float, $.a_empty_obj_nested.o3] |
+| [$.a_str, $.a_empty_array, $.a_null, $.a_num_int, $.a_bool, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_empty_obj_nested.o2, $.a_num_float, $.a_empty_obj_nested.o3] |
+| [$.a_str, $.a_empty_array, $.a_null, $.a_num_int, $.a_bool, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_empty_obj_nested.o2, $.a_num_float, $.a_empty_obj_nested.o3] |
+| [$.a_str, $.a_empty_array, $.a_null, $.a_num_int, $.a_bool, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_empty_obj_nested.o2, $.a_num_float, $.a_empty_obj_nested.o3] |
+| [$]                                                                                                                                                                                |
+| [$]                                                                                                                                                                                |
+| [$]                                                                                                                                                                                |
+| [$]                                                                                                                                                                                |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(8 rows)
+
+!ok
+
+#-------------------------------------------------------------------------
+# TESTCASE: test_func_json_paths TEST_ID: A100 TYPE: POSITIVE TEST
+#-------------------------------------------------------------------------
+
+SELECT json_paths(c1)
+FROM test_json_cols;
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| EXPR$0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [$.a_array[1].a_array[1].a_str, $.a_obj.a_obj.a_bool, $.a_array[1].a_array[0].a_empty_obj_nested.o2, $.a_array[1].a_array[0].a_empty_obj_nested.o3, $.a_obj.a_array[0].a_num_float, $.a_array[1].a_array[0].a_empty_array_nested[1], $.a_array[1].a_array[0].a_empty_array_nested[2], $.a_obj.a_array[0].a_str, $.a_obj.a_array[1].a_null, $.a_str, $.a_array[0].a_obj.a_num_float, $.a_null, $.a_array[0].a_str, $.a_array[1].a_num_float, $.a_array[1].a_array[1].a_num_float, $.a_array[1].a_obj.a_bool, $.a_array[1].a_array[1].a_null, $.a_obj.a_array[1].a_num_float, $.a_array[1].a_num_int, $.a_num_int, $.a_array[0].a_empty_array_nested[2], $.a_array[0].a_empty_array_nested[1], $.a_array[0].a_array[1].a_bool, $.a_obj.a_array[1].a_str, $.a_array[1].a_null, $.a_array[0].a_empty_obj_nested.o2, $.a_array[0].a_empty_obj_nested.o3, $.a_array[1].a_array[0].a_num_float, $.a_array[0].a_num_float, $.a_array[0].a_array[0].a_empty_array, $.a_array[1].a_empty_array, $.a_array[1].a_obj.a_str, $.a_array[0].a_obj.a_num_int, $.a_array[0].a_obj.a_null, $.a_array[1].a_array[1].a_empty_obj_nested.o3, $.a_obj.a_obj.a_num_float, $.a_array[0].a_num_int, $.a_array[0].a_bool, $.a_array[1].a_array[1].a_empty_obj_nested.o2, $.a_obj.a_array[0].a_num_int, $.a_obj.a_array[0].a_bool, $.a_array[1].a_array[1].a_num_int, $.a_array[0].a_array[0].a_bool, $.a_array[1].a_array[0].a_null, $.a_array[0].a_obj.a_empty_obj_nested.o2, $.a_array[0].a_obj.a_empty_obj_nested.o3, $.a_obj.a_bool, $.a_array[1].a_obj.a_num_float, $.a_obj.a_array[1].a_empty_obj_nested.o3, $.a_array[0].a_array[1].a_empty_array, $.a_obj.a_array[1].a_empty_obj_nested.o2, $.a_array[0].a_obj.a_bool, $.a_obj.a_array[1].a_num_int, $.a_obj.a_array[1].a_bool, $.a_num_float, $.a_array[1].a_str, $.a_array[1].a_empty_obj_nested.o3, $.a_array[1].a_empty_obj_nested.o2, $.a_obj.a_obj.a_empty_array_nested[1], $.a_obj.a_obj.a_empty_array_nested[2], $.a_array[0].a_array[1].a_empty_array_nested[1], $.a_array[0].a_obj.a_str, $.a_array[0].a_array[1].a_empty_array_nested[2], $.a_array[1].a_obj.a_num_int, $.a_obj.a_obj.a_num_int, $.a_array[0].a_array[0].a_str, $.a_obj.a_str, $.a_array[0].a_array[0].a_empty_array_nested[1], $.a_array[0].a_array[0].a_empty_obj_nested.o2, $.a_array[1].a_obj.a_empty_array, $.a_array[0].a_array[1].a_null, $.a_obj.a_num_float, $.a_array[0].a_array[0].a_num_float, $.a_obj.a_obj.a_empty_array, $.a_obj.a_array[0].a_empty_obj_nested.o2, $.a_obj.a_array[0].a_empty_obj_nested.o3, $.a_array[1].a_array[0].a_empty_array, $.a_obj.a_array[0].a_empty_array_nested[1], $.a_obj.a_array[0].a_empty_array_nested[2], $.a_obj.a_empty_obj_nested.o3, $.a_array[0].a_array[1].a_str, $.a_obj.a_null, $.a_array[1].a_bool, $.a_obj.a_empty_obj_nested.o2, $.a_bool, $.a_array[1].a_array[0].a_num_int, $.a_obj.a_obj.a_null, $.a_array[0].a_array[0].a_null, $.a_array[1].a_obj.a_empty_obj_nested.o3, $.a_obj.a_num_int, $.a_array[1].a_obj.a_empty_obj_nested.o2, $.a_array[0].a_array[0].a_empty_obj_nested.o3, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_obj.a_empty_array_nested[1], $.a_obj.a_empty_array_nested[2], $.a_array[1].a_obj.a_empty_array_nested[2], $.a_array[0].a_array[0].a_empty_array_nested[2], $.a_array[1].a_array[1].a_empty_array, $.a_empty_obj_nested.o2, $.a_empty_obj_nested.o3, $.a_array[1].a_obj.a_empty_array_nested[1], $.a_empty_array, $.a_array[0].a_obj.a_empty_array, $.a_array[1].a_array[1].a_empty_array_nested[2], $.a_obj.a_empty_array, $.a_array[1].a_array[1].a_bool, $.a_array[1].a_array[1].a_empty_array_nested[1], $.a_array[0].a_array[0].a_num_int, $.a_obj.a_obj.a_str, $.a_array[0].a_null, $.a_obj.a_array[0].a_empty_array, $.a_obj.a_array[1].a_empty_array_nested[2], $.a_array[0].a_obj.a_empty_array_nested[1], $.a_array[0].a_obj.a_empty_array_nested[2], $.a_array[0].a_empty_array, $.a_obj.a_array[1].a_empty_array_nested[1], $.a_obj.a_array[0].a_null, $.a_array[1].a_array[0].a_str, $.a_array[1].a_empty_array_nested[1], $.a_array[1].a_array[0].a_bool, $.a_array[0].a_array[1].a_num_int, $.a_array[1].a_empty_array_nested[2], $.a_obj.a_array[1].a_empty_array, $.a_array[0].a_array[1].a_num_float, $.a_array[0].a_array[1].a_empty_obj_nested.o2, $.a_array[0].a_array[1].a_empty_obj_nested.o3, $.a_obj.a_obj.a_empty_obj_nested.o2, $.a_array[1].a_obj.a_null, $.a_obj.a_obj.a_empty_obj_nested.o3] |
+| [$.a_array[1].a_array[1].a_str, $.a_obj.a_obj.a_bool, $.a_array[1].a_array[0].a_empty_obj_nested.o2, $.a_array[1].a_array[0].a_empty_obj_nested.o3, $.a_obj.a_array[0].a_num_float, $.a_array[1].a_array[0].a_empty_array_nested[1], $.a_array[1].a_array[0].a_empty_array_nested[2], $.a_obj.a_array[0].a_str, $.a_obj.a_array[1].a_null, $.a_str, $.a_array[0].a_obj.a_num_float, $.a_null, $.a_array[0].a_str, $.a_array[1].a_num_float, $.a_array[1].a_array[1].a_num_float, $.a_array[1].a_obj.a_bool, $.a_array[1].a_array[1].a_null, $.a_obj.a_array[1].a_num_float, $.a_array[1].a_num_int, $.a_num_int, $.a_array[0].a_empty_array_nested[2], $.a_array[0].a_empty_array_nested[1], $.a_array[0].a_array[1].a_bool, $.a_obj.a_array[1].a_str, $.a_array[1].a_null, $.a_array[0].a_empty_obj_nested.o2, $.a_array[0].a_empty_obj_nested.o3, $.a_array[1].a_array[0].a_num_float, $.a_array[0].a_num_float, $.a_array[0].a_array[0].a_empty_array, $.a_array[1].a_empty_array, $.a_array[1].a_obj.a_str, $.a_array[0].a_obj.a_num_int, $.a_array[0].a_obj.a_null, $.a_array[1].a_array[1].a_empty_obj_nested.o3, $.a_obj.a_obj.a_num_float, $.a_array[0].a_num_int, $.a_array[0].a_bool, $.a_array[1].a_array[1].a_empty_obj_nested.o2, $.a_obj.a_array[0].a_num_int, $.a_obj.a_array[0].a_bool, $.a_array[1].a_array[1].a_num_int, $.a_array[0].a_array[0].a_bool, $.a_array[1].a_array[0].a_null, $.a_array[0].a_obj.a_empty_obj_nested.o2, $.a_array[0].a_obj.a_empty_obj_nested.o3, $.a_obj.a_bool, $.a_array[1].a_obj.a_num_float, $.a_obj.a_array[1].a_empty_obj_nested.o3, $.a_array[0].a_array[1].a_empty_array, $.a_obj.a_array[1].a_empty_obj_nested.o2, $.a_array[0].a_obj.a_bool, $.a_obj.a_array[1].a_num_int, $.a_obj.a_array[1].a_bool, $.a_num_float, $.a_array[1].a_str, $.a_array[1].a_empty_obj_nested.o3, $.a_array[1].a_empty_obj_nested.o2, $.a_obj.a_obj.a_empty_array_nested[1], $.a_obj.a_obj.a_empty_array_nested[2], $.a_array[0].a_array[1].a_empty_array_nested[1], $.a_array[0].a_obj.a_str, $.a_array[0].a_array[1].a_empty_array_nested[2], $.a_array[1].a_obj.a_num_int, $.a_obj.a_obj.a_num_int, $.a_array[0].a_array[0].a_str, $.a_obj.a_str, $.a_array[0].a_array[0].a_empty_array_nested[1], $.a_array[0].a_array[0].a_empty_obj_nested.o2, $.a_array[1].a_obj.a_empty_array, $.a_array[0].a_array[1].a_null, $.a_obj.a_num_float, $.a_array[0].a_array[0].a_num_float, $.a_obj.a_obj.a_empty_array, $.a_obj.a_array[0].a_empty_obj_nested.o2, $.a_obj.a_array[0].a_empty_obj_nested.o3, $.a_array[1].a_array[0].a_empty_array, $.a_obj.a_array[0].a_empty_array_nested[1], $.a_obj.a_array[0].a_empty_array_nested[2], $.a_obj.a_empty_obj_nested.o3, $.a_array[0].a_array[1].a_str, $.a_obj.a_null, $.a_array[1].a_bool, $.a_obj.a_empty_obj_nested.o2, $.a_bool, $.a_array[1].a_array[0].a_num_int, $.a_obj.a_obj.a_null, $.a_array[0].a_array[0].a_null, $.a_array[1].a_obj.a_empty_obj_nested.o3, $.a_obj.a_num_int, $.a_array[1].a_obj.a_empty_obj_nested.o2, $.a_array[0].a_array[0].a_empty_obj_nested.o3, $.a_empty_array_nested[1], $.a_empty_array_nested[2], $.a_obj.a_empty_array_nested[1], $.a_obj.a_empty_array_nested[2], $.a_array[1].a_obj.a_empty_array_nested[2], $.a_array[0].a_array[0].a_empty_array_nested[2], $.a_array[1].a_array[1].a_empty_array, $.a_empty_obj_nested.o2, $.a_empty_obj_nested.o3, $.a_array[1].a_obj.a_empty_array_nested[1], $.a_empty_array, $.a_array[0].a_obj.a_empty_array, $.a_array[1].a_array[1].a_empty_array_nested[2], $.a_obj.a_empty_array, $.a_array[1].a_array[1].a_bool, $.a_array[1].a_array[1].a_empty_array_nested[1], $.a_array[0].a_array[0].a_num_int, $.a_obj.a_obj.a_str, $.a_array[0].a_null, $.a_obj.a_array[0].a_empty_array, $.a_obj.a_array[1].a_empty_array_nested[2], $.a_array[0].a_obj.a_empty_array_nested[1], $.a_array[0].a_obj.a_empty_array_nested[2], $.a_array[0].a_empty_array, $.a_obj.a_array[1].a_empty_array_nested[1], $.a_obj.a_array[0].a_null, $.a_array[1].a_array[0].a_str, $.a_array[1].a_empty_array_nested[1], $.a_array[1].a_array[0].a_bool, $.a_array[0].a_array[1].a_num_int, $.a_array[1].a_empty_array_nested[2], $.a_obj.a_array[1].a_empty_array, $.a_array[0].a_array[1].a_num_float, $.a_array[0].a_array[1].a_empty_obj_nested.o2, $.a_array[0].a_array[1].a_empty_obj_nested.o3, $.a_obj.a_obj.a_empty_obj_nested.o2, $.a_array[1].a_obj.a_null, $.a_obj.a_obj.a_empty_obj_nested.o3] |
+| [$.b_array[1].b_bool, $.b_array[1].b_array[0].b_num_int, $.b_array[0].b_array[0].b_num_float, $.b_obj.b_array[0].b_empty_array_nested[1], $.b_obj.b_array[0].b_empty_array_nested[2], $.b_array[0].b_obj.b_bool, $.b_array[1].b_obj.b_str, $.b_obj.b_num_int, $.b_array[0].b_array[1].b_null, $.b_obj.b_array[0].b_bool, $.b_array[1].b_array[0].b_str, $.b_num_float, $.b_array[0].b_array[1].b_empty_obj_nested.o3, $.b_obj.b_str, $.b_array[0].b_str, $.b_array[0].b_bool, $.b_array[0].b_array[1].b_empty_obj_nested.o2, $.b_null, $.b_obj.b_obj.b_empty_obj_nested.o3, $.b_obj.b_obj.b_empty_obj_nested.o2, $.b_array[0].b_array[1].b_empty_array, $.b_array[0].b_array[0].b_empty_array_nested[1], $.b_array[0].b_array[0].b_empty_array_nested[2], $.b_obj.b_empty_obj_nested.o2, $.b_obj.b_array[1].b_empty_obj_nested.o2, $.b_obj.b_array[1].b_empty_obj_nested.o3, $.b_array[0].b_array[0].b_empty_array, $.b_obj.b_empty_obj_nested.o3, $.b_array[0].b_obj.b_str, $.b_obj.b_array[1].b_bool, $.b_obj.b_array[0].b_str, $.b_obj.b_array[0].b_num_int, $.b_array[1].b_str, $.b_obj.b_array[1].b_num_float, $.b_bool, $.b_array[1].b_obj.b_bool, $.b_array[1].b_obj.b_empty_array, $.b_array[1].b_array[1].b_empty_array, $.b_empty_array_nested[2], $.b_empty_array_nested[1], $.b_array[1].b_array[1].b_bool, $.b_array[0].b_empty_obj_nested.o2, $.b_array[0].b_empty_obj_nested.o3, $.b_array[1].b_array[1].b_empty_array_nested[1], $.b_array[1].b_array[1].b_empty_array_nested[2], $.b_obj.b_empty_array, $.b_array[0].b_empty_array, $.b_obj.b_obj.b_num_float, $.b_array[1].b_array[1].b_num_int, $.b_obj.b_array[1].b_null, $.b_array[0].b_array[1].b_num_float, $.b_array[1].b_empty_array_nested[1], $.b_array[1].b_array[1].b_empty_obj_nested.o3, $.b_array[1].b_array[1].b_empty_obj_nested.o2, $.b_array[1].b_array[0].b_empty_array, $.b_array[0].b_array[0].b_null, $.b_array[1].b_empty_array_nested[2], $.b_array[1].b_array[1].b_str, $.b_obj.b_obj.b_empty_array_nested[2], $.b_obj.b_obj.b_empty_array_nested[1], $.b_obj.b_obj.b_null, $.b_array[1].b_obj.b_num_int, $.b_obj.b_obj.b_num_int, $.b_array[0].b_obj.b_empty_obj_nested.o3, $.b_array[0].b_obj.b_empty_obj_nested.o2, $.b_str, $.b_empty_obj_nested.o2, $.b_obj.b_array[0].b_null, $.b_empty_obj_nested.o3, $.b_array[1].b_empty_array, $.b_array[1].b_array[1].b_num_float, $.b_array[0].b_obj.b_empty_array, $.b_obj.b_array[1].b_empty_array, $.b_array[0].b_obj.b_null, $.b_num_int, $.b_array[1].b_array[0].b_empty_obj_nested.o2, $.b_array[1].b_null, $.b_array[1].b_empty_obj_nested.o2, $.b_array[1].b_empty_obj_nested.o3, $.b_array[1].b_array[0].b_empty_array_nested[2], $.b_array[1].b_array[0].b_empty_array_nested[1], $.b_obj.b_bool, $.b_obj.b_array[0].b_num_float, $.b_obj.b_array[1].b_num_int, $.b_array[1].b_array[0].b_num_float, $.b_array[0].b_empty_array_nested[2], $.b_array[0].b_empty_array_nested[1], $.b_array[1].b_array[0].b_empty_obj_nested.o3, $.b_array[1].b_num_int, $.b_array[0].b_num_float, $.b_array[1].b_num_float, $.b_array[1].b_array[0].b_bool, $.b_array[0].b_obj.b_empty_array_nested[2], $.b_obj.b_num_float, $.b_array[0].b_obj.b_empty_array_nested[1], $.b_array[0].b_obj.b_num_float, $.b_array[0].b_null, $.b_array[0].b_obj.b_num_int, $.b_empty_array, $.b_array[0].b_array[1].b_num_int, $.b_obj.b_array[1].b_empty_array_nested[2], $.b_obj.b_array[1].b_empty_array_nested[1], $.b_array[0].b_num_int, $.b_array[1].b_array[0].b_null, $.b_array[1].b_obj.b_null, $.b_array[0].b_array[1].b_empty_array_nested[2], $.b_obj.b_obj.b_bool, $.b_array[0].b_array[0].b_bool, $.b_obj.b_obj.b_empty_array, $.b_array[0].b_array[1].b_str, $.b_array[1].b_obj.b_empty_array_nested[1], $.b_array[1].b_obj.b_empty_array_nested[2], $.b_obj.b_null, $.b_obj.b_array[1].b_str, $.b_obj.b_empty_array_nested[2], $.b_array[0].b_array[0].b_num_int, $.b_obj.b_empty_array_nested[1], $.b_array[1].b_obj.b_empty_obj_nested.o3, $.b_array[0].b_array[0].b_empty_obj_nested.o3, $.b_array[1].b_obj.b_empty_obj_nested.o2, $.b_array[0].b_array[0].b_empty_obj_nested.o2, $.b_array[1].b_array[1].b_null, $.b_obj.b_array[0].b_empty_array, $.b_array[0].b_array[1].b_empty_array_nested[1], $.b_obj.b_array[0].b_empty_obj_nested.o3, $.b_array[0].b_array[1].b_bool, $.b_obj.b_array[0].b_empty_obj_nested.o2, $.b_array[0].b_array[0].b_str, $.b_obj.b_obj.b_str, $.b_array[1].b_obj.b_num_float] |
+| [$.b_array[1].b_bool, $.b_array[1].b_array[0].b_num_int, $.b_array[0].b_array[0].b_num_float, $.b_obj.b_array[0].b_empty_array_nested[1], $.b_obj.b_array[0].b_empty_array_nested[2], $.b_array[0].b_obj.b_bool, $.b_array[1].b_obj.b_str, $.b_obj.b_num_int, $.b_array[0].b_array[1].b_null, $.b_obj.b_array[0].b_bool, $.b_array[1].b_array[0].b_str, $.b_num_float, $.b_array[0].b_array[1].b_empty_obj_nested.o3, $.b_obj.b_str, $.b_array[0].b_str, $.b_array[0].b_bool, $.b_array[0].b_array[1].b_empty_obj_nested.o2, $.b_null, $.b_obj.b_obj.b_empty_obj_nested.o3, $.b_obj.b_obj.b_empty_obj_nested.o2, $.b_array[0].b_array[1].b_empty_array, $.b_array[0].b_array[0].b_empty_array_nested[1], $.b_array[0].b_array[0].b_empty_array_nested[2], $.b_obj.b_empty_obj_nested.o2, $.b_obj.b_array[1].b_empty_obj_nested.o2, $.b_obj.b_array[1].b_empty_obj_nested.o3, $.b_array[0].b_array[0].b_empty_array, $.b_obj.b_empty_obj_nested.o3, $.b_array[0].b_obj.b_str, $.b_obj.b_array[1].b_bool, $.b_obj.b_array[0].b_str, $.b_obj.b_array[0].b_num_int, $.b_array[1].b_str, $.b_obj.b_array[1].b_num_float, $.b_bool, $.b_array[1].b_obj.b_bool, $.b_array[1].b_obj.b_empty_array, $.b_array[1].b_array[1].b_empty_array, $.b_empty_array_nested[2], $.b_empty_array_nested[1], $.b_array[1].b_array[1].b_bool, $.b_array[0].b_empty_obj_nested.o2, $.b_array[0].b_empty_obj_nested.o3, $.b_array[1].b_array[1].b_empty_array_nested[1], $.b_array[1].b_array[1].b_empty_array_nested[2], $.b_obj.b_empty_array, $.b_array[0].b_empty_array, $.b_obj.b_obj.b_num_float, $.b_array[1].b_array[1].b_num_int, $.b_obj.b_array[1].b_null, $.b_array[0].b_array[1].b_num_float, $.b_array[1].b_empty_array_nested[1], $.b_array[1].b_array[1].b_empty_obj_nested.o3, $.b_array[1].b_array[1].b_empty_obj_nested.o2, $.b_array[1].b_array[0].b_empty_array, $.b_array[0].b_array[0].b_null, $.b_array[1].b_empty_array_nested[2], $.b_array[1].b_array[1].b_str, $.b_obj.b_obj.b_empty_array_nested[2], $.b_obj.b_obj.b_empty_array_nested[1], $.b_obj.b_obj.b_null, $.b_array[1].b_obj.b_num_int, $.b_obj.b_obj.b_num_int, $.b_array[0].b_obj.b_empty_obj_nested.o3, $.b_array[0].b_obj.b_empty_obj_nested.o2, $.b_str, $.b_empty_obj_nested.o2, $.b_obj.b_array[0].b_null, $.b_empty_obj_nested.o3, $.b_array[1].b_empty_array, $.b_array[1].b_array[1].b_num_float, $.b_array[0].b_obj.b_empty_array, $.b_obj.b_array[1].b_empty_array, $.b_array[0].b_obj.b_null, $.b_num_int, $.b_array[1].b_array[0].b_empty_obj_nested.o2, $.b_array[1].b_null, $.b_array[1].b_empty_obj_nested.o2, $.b_array[1].b_empty_obj_nested.o3, $.b_array[1].b_array[0].b_empty_array_nested[2], $.b_array[1].b_array[0].b_empty_array_nested[1], $.b_obj.b_bool, $.b_obj.b_array[0].b_num_float, $.b_obj.b_array[1].b_num_int, $.b_array[1].b_array[0].b_num_float, $.b_array[0].b_empty_array_nested[2], $.b_array[0].b_empty_array_nested[1], $.b_array[1].b_array[0].b_empty_obj_nested.o3, $.b_array[1].b_num_int, $.b_array[0].b_num_float, $.b_array[1].b_num_float, $.b_array[1].b_array[0].b_bool, $.b_array[0].b_obj.b_empty_array_nested[2], $.b_obj.b_num_float, $.b_array[0].b_obj.b_empty_array_nested[1], $.b_array[0].b_obj.b_num_float, $.b_array[0].b_null, $.b_array[0].b_obj.b_num_int, $.b_empty_array, $.b_array[0].b_array[1].b_num_int, $.b_obj.b_array[1].b_empty_array_nested[2], $.b_obj.b_array[1].b_empty_array_nested[1], $.b_array[0].b_num_int, $.b_array[1].b_array[0].b_null, $.b_array[1].b_obj.b_null, $.b_array[0].b_array[1].b_empty_array_nested[2], $.b_obj.b_obj.b_bool, $.b_array[0].b_array[0].b_bool, $.b_obj.b_obj.b_empty_array, $.b_array[0].b_array[1].b_str, $.b_array[1].b_obj.b_empty_array_nested[1], $.b_array[1].b_obj.b_empty_array_nested[2], $.b_obj.b_null, $.b_obj.b_array[1].b_str, $.b_obj.b_empty_array_nested[2], $.b_array[0].b_array[0].b_num_int, $.b_obj.b_empty_array_nested[1], $.b_array[1].b_obj.b_empty_obj_nested.o3, $.b_array[0].b_array[0].b_empty_obj_nested.o3, $.b_array[1].b_obj.b_empty_obj_nested.o2, $.b_array[0].b_array[0].b_empty_obj_nested.o2, $.b_array[1].b_array[1].b_null, $.b_obj.b_array[0].b_empty_array, $.b_array[0].b_array[1].b_empty_array_nested[1], $.b_obj.b_array[0].b_empty_obj_nested.o3, $.b_array[0].b_array[1].b_bool, $.b_obj.b_array[0].b_empty_obj_nested.o2, $.b_array[0].b_array[0].b_str, $.b_obj.b_obj.b_str, $.b_array[1].b_obj.b_num_float] |
++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+(4 rows)
+
+!ok
+
+{
+  "queryType" : "scan",
+  "dataSource" : {
+    "type" : "table",
+    "name" : "test_json_cols"
+  },
+  "intervals" : {
+    "type" : "intervals",
+    "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ]
+  },
+  "virtualColumns" : [ {
+    "type" : "expression",
+    "name" : "v0",
+    "expression" : "json_paths(\"c1\")",
+    "outputType" : "ARRAY<STRING>"
+  } ],
+  "resultFormat" : "compactedList",
+  "columns" : [ "v0" ],
+  "columnTypes" : [ "ARRAY<STRING>" ],
+  "granularity" : {
+    "type" : "all"
+  },
+  "legacy" : false
+}
+!nativePlan
+
+#-------------------------------------------------------------------------
+# Total query count 985 Positive tests: 823 Negative tests: 162
+#-------------------------------------------------------------------------
diff --git a/sql/src/test/quidem/qatests/qaAggFuncs/ingest.json b/sql/src/test/quidem/qatests/qaAggFuncs/ingest.json
new file mode 100644
index 000000000000..c04242dc16ac
--- /dev/null
+++ b/sql/src/test/quidem/qatests/qaAggFuncs/ingest.json
@@ -0,0 +1,66 @@
+{
+  "type": "index_parallel",
+  "spec": {
+    "ioConfig": {
+      "type": "index_parallel",
+      "inputSource": {
+        "type": "inline",
+        "data": "2020-01-01 01:01:01.000,1111111111,AAAAAAAAAA,11.11111111,111.1111111\n2020-01-01 01:01:01.000,1111111111,BBBBBBBBBB,11.11111111,111.1111111\n2020-01-01 01:01:01.000,1111111111,,11.11111111,111.1111111\n2020-01-01 01:01:01.000,2222222222,AAAAAAAAAA,22.22222222,222.2222222\n2020-01-01 01:01:01.000,2222222222,BBBBBBBBBB,22.22222222,222.2222222\n2020-01-01 01:01:01.000,2222222222,,22.22222222,222.2222222\n2020-01-01 01:01:01.000,,AAAAAAAAAA,,\n2020-01-01 01:01:01.000,,BBBBBBBBBB,,\n2020-01-01 01:01:01.000,,,,\n2020-02-01 01:01:01.000,1111111111,AAAAAAAAAA,11.11111111,111.1111111\n2020-02-01 01:01:01.000,1111111111,BBBBBBBBBB,11.11111111,111.1111111\n2020-02-01 01:01:01.000,1111111111,,11.11111111,111.1111111\n2020-02-01 01:01:01.000,2222222222,AAAAAAAAAA,22.22222222,222.2222222\n2020-02-01 01:01:01.000,2222222222,BBBBBBBBBB,22.22222222,222.2222222\n2020-02-01 01:01:01.000,2222222222,,22.22222222,222.2222222\n2020-02-01 01:01:01.000,,AAAAAAAAAA,,\n2020-02-01 01:01:01.000,,BBBBBBBBBB,,\n2020-02-01 01:01:01.000,,,,\n"
+      },
+      "inputFormat": {
+        "type": "csv",
+        "columns": [
+          "timestamp",
+          "tab0l0",
+          "tab0s0",
+          "tab0f0",
+          "tab0d0"
+        ],
+        "findColumnsFromHeader": false
+      }
+    },
+    "tuningConfig": {
+      "type": "index_parallel",
+      "partitionsSpec": {
+        "type": "dynamic",
+        "maxRowsPerSegment": 10000000,
+        "maxTotalRows": 500000000
+      },
+      "maxNumConcurrentSubTasks": 1
+    },
+    "dataSchema": {
+      "dataSource": "test_agg_funcs",
+      "granularitySpec": {
+        "type": "uniform",
+        "queryGranularity": "NONE",
+        "rollup": false,
+        "segmentGranularity": "MONTH"
+      },
+      "timestampSpec": {
+        "column": "timestamp",
+        "format": "auto"
+      },
+      "dimensionsSpec": {
+        "dimensions": [
+          {
+            "type": "long",
+            "name": "tab0l0"
+          },
+          {
+            "type": "string",
+            "name": "tab0s0",
+            "createBitmapIndex": true
+          },
+          {
+            "type": "float",
+            "name": "tab0f0"
+          },
+          {
+            "type": "double",
+            "name": "tab0d0"
+          }
+        ]
+      } 
+    }
+  }
+}
diff --git a/sql/src/test/quidem/qatests/qaArray/ops_funcs/ingest.json b/sql/src/test/quidem/qatests/qaArray/ops_funcs/ingest.json
new file mode 100644
index 000000000000..6a308e89736e
--- /dev/null
+++ b/sql/src/test/quidem/qatests/qaArray/ops_funcs/ingest.json
@@ -0,0 +1,219 @@
+{
+  "type": "index_parallel",
+  "spec": {
+    "ioConfig": {
+      "type": "index_parallel",
+      "inputSource": {
+        "type": "inline",
+        "data": "{\"timestamp\":\"2022-01-01T00:00:00\",\"a_bool\":[true,false,null],\"a_int\":[1,2,null],\"a_float\":[0.1,0.2,null],\"a_str\":[\"S1\",\"S2\",null],\"a_null\":[null,null,null],\"a_empty\":[],\"a_mixed\":[true,1,0.1,\"S1\",null],\"a_nested\":[[true,false,null],[1,2,null],[0.1,0.2,null],[\"S1\",\"S2\",null],[null,null,null],[],[true,1,0.1,\"S1\",null],[[true,false,null],[1,2,null],[0.1,0.2,null],[\"S1\",\"S2\",null],[null,null,null],[],[true,1,0.1,\"S1\",null],[[true,false,null],[1,2,null],[0.1,0.2,null],[\"S1\",\"S2\",null],[null,null,null],[],[true,1,0.1,\"S1\",null]]]]}\n{\"timestamp\":\"2022-01-01T00:00:00\",\"a_bool\":[true,false,null],\"a_int\":[1,2,null],\"a_float\":[0.1,0.2,null],\"a_str\":[\"S1\",\"S2\",null],\"a_null\":[null,null,null],\"a_empty\":[],\"a_mixed\":[true,1,0.1,\"S1\",null],\"a_nested\":[[true,false,null],[1,2,null],[0.1,0.2,null],[\"S1\",\"S2\",null],[null,null,null],[],[true,1,0.1,\"S1\",null],[[true,false,null],[1,2,null],[0.1,0.2,null],[\"S1\",\"S2\",null],[null,null,null],[],[true,1,0.1,\"S1\",null],[[true,false,null],[1,2,null],[0.1,0.2,null],[\"S1\",\"S2\",null],[null,null,null],[],[true,1,0.1,\"S1\",null]]]]}\n{\"timestamp\":\"2022-02-01T00:00:00\",\"a_bool\":[null,false,true],\"a_int\":[null,2,1],\"a_float\":[null,0.2,0.1],\"a_str\":[null,\"S2\",\"S1\"],\"a_null\":[null,null,null],\"a_empty\":[],\"a_mixed\":[null,\"S1\",0.1,1,true],\"a_nested\":[[null,false,true],[null,2,1],[null,0.2,0.1],[null,\"S2\",\"S1\"],[null,null,null],[],[null,\"S1\",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,\"S2\",\"S1\"],[null,null,null],[],[null,\"S1\",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,\"S2\",\"S1\"],[null,null,null],[],[null,\"S1\",0.1,1,true]]]]}\n{\"timestamp\":\"2022-02-01T00:00:00\",\"a_bool\":[null,false,true],\"a_int\":[null,2,1],\"a_float\":[null,0.2,0.1],\"a_str\":[null,\"S2\",\"S1\"],\"a_null\":[null,null,null],\"a_empty\":[],\"a_mixed\":[null,\"S1\",0.1,1,true],\"a_nested\":[[null,false,true],[null,2,1],[null,0.2,0.1],[null,\"S2\",\"S1\"],[null,null,null],[],[null,\"S1\",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,\"S2\",\"S1\"],[null,null,null],[],[null,\"S1\",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,\"S2\",\"S1\"],[null,null,null],[],[null,\"S1\",0.1,1,true]]]]}\n"
+      },
+      "inputFormat": {
+        "type": "json"
+      },
+      "appendToExisting": false
+    },
+    "tuningConfig": {
+      "type": "index_parallel",
+      "partitionsSpec": {
+        "type": "dynamic",
+        "maxRowsPerSegment": 10000000,
+        "maxTotalRows": 500000000
+      },
+      "maxNumConcurrentSubTasks": 1,
+      "indexSpec": {
+        "stringDictionaryEncoding": {
+          "type": "frontCoded",
+          "bucketSize": 4,
+          "formatVersion": 1
+        }
+      }
+    },
+    "dataSchema": {
+      "dataSource": "test_array",
+      "granularitySpec": {
+        "type": "uniform",
+        "queryGranularity": "NONE",
+        "rollup": false,
+        "segmentGranularity": "MONTH"
+      },
+      "timestampSpec": {
+        "column": "timestamp",
+        "format": "auto"
+      },
+      "dimensionsSpec": {
+        "dimensions": [
+          {
+            "name": "a_bool",
+            "type": "auto"
+          },
+          {
+            "name": "a_int",
+            "type": "auto"
+          },
+          {
+            "name": "a_float",
+            "type": "auto"
+          },
+          {
+            "name": "a_str",
+            "type": "auto"
+          },
+          {
+            "name": "a_null",
+            "type": "auto"
+          },
+          {
+            "name": "a_empty",
+            "type": "auto"
+          },
+          {
+            "name": "a_mixed",
+            "type": "auto"
+          },
+          {
+            "name": "a_nested",
+            "type": "auto"
+          },
+          {
+            "name": "t_bool_scalar1",
+            "type": "auto"
+          },
+          {
+            "name": "t_bool_scalar2",
+            "type": "auto"
+          },
+          {
+            "name": "t_int_scalar1",
+            "type": "auto"
+          },
+          {
+            "name": "t_int_scalar2",
+            "type": "auto"
+          },
+          {
+            "name": "t_float_scalar1",
+            "type": "auto"
+          },
+          {
+            "name": "t_float_scalar2",
+            "type": "auto"
+          },
+          {
+            "name": "t_str_scalar1",
+            "type": "auto"
+          },
+          {
+            "name": "t_str_scalar2",
+            "type": "auto"
+          },
+          {
+            "name": "t_null_scalar1",
+            "type": "auto"
+          },
+          {
+            "name": "t_null_scalar2",
+            "type": "auto"
+          },
+          {
+            "name": "t_empty_scalar1",
+            "type": "auto"
+          },
+          {
+            "name": "t_empty_scalar2",
+            "type": "auto"
+          },
+          {
+            "name": "t_mixed_scalar1",
+            "type": "auto"
+          },
+          {
+            "name": "t_mixed_scalar2",
+            "type": "auto"
+          }
+        ]
+      },
+      "metricsSpec": [
+        {
+          "name": "cnt",
+          "type": "count"
+        }
+      ],
+      "transformSpec": {
+        "transforms": [
+          {
+            "type": "expression",
+            "name": "t_bool_scalar1",
+            "expression": "json_value(a_bool, '$[0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_bool_scalar2",
+            "expression": "json_value(a_nested, '$[0][0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_int_scalar1",
+            "expression": "json_value(a_int, '$[0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_int_scalar2",
+            "expression": "json_value(a_nested, '$[1][0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_float_scalar1",
+            "expression": "json_value(a_float, '$[0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_float_scalar2",
+            "expression": "json_value(a_nested, '$[2][0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_str_scalar1",
+            "expression": "json_value(a_str, '$[0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_str_scalar2",
+            "expression": "json_value(a_nested, '$[3][0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_null_scalar1",
+            "expression": "json_value(a_null, '$[0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_null_scalar2",
+            "expression": "json_value(a_nested, '$[4][0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_empty_scalar1",
+            "expression": "json_value(a_empty, '$[0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_empty_scalar2",
+            "expression": "json_value(a_nested, '$[5][0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_mixed_scalar1",
+            "expression": "json_value(a_mixed, '$[0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_mixed_scalar2",
+            "expression": "json_value(a_nested, '$[6][0]')"
+          }
+        ]
+      }
+    }
+  },
+  "context": null
+}
+
diff --git a/sql/src/test/quidem/qatests/qaArray/sql/ingest.json b/sql/src/test/quidem/qatests/qaArray/sql/ingest.json
new file mode 100644
index 000000000000..6a308e89736e
--- /dev/null
+++ b/sql/src/test/quidem/qatests/qaArray/sql/ingest.json
@@ -0,0 +1,219 @@
+{
+  "type": "index_parallel",
+  "spec": {
+    "ioConfig": {
+      "type": "index_parallel",
+      "inputSource": {
+        "type": "inline",
+        "data": "{\"timestamp\":\"2022-01-01T00:00:00\",\"a_bool\":[true,false,null],\"a_int\":[1,2,null],\"a_float\":[0.1,0.2,null],\"a_str\":[\"S1\",\"S2\",null],\"a_null\":[null,null,null],\"a_empty\":[],\"a_mixed\":[true,1,0.1,\"S1\",null],\"a_nested\":[[true,false,null],[1,2,null],[0.1,0.2,null],[\"S1\",\"S2\",null],[null,null,null],[],[true,1,0.1,\"S1\",null],[[true,false,null],[1,2,null],[0.1,0.2,null],[\"S1\",\"S2\",null],[null,null,null],[],[true,1,0.1,\"S1\",null],[[true,false,null],[1,2,null],[0.1,0.2,null],[\"S1\",\"S2\",null],[null,null,null],[],[true,1,0.1,\"S1\",null]]]]}\n{\"timestamp\":\"2022-01-01T00:00:00\",\"a_bool\":[true,false,null],\"a_int\":[1,2,null],\"a_float\":[0.1,0.2,null],\"a_str\":[\"S1\",\"S2\",null],\"a_null\":[null,null,null],\"a_empty\":[],\"a_mixed\":[true,1,0.1,\"S1\",null],\"a_nested\":[[true,false,null],[1,2,null],[0.1,0.2,null],[\"S1\",\"S2\",null],[null,null,null],[],[true,1,0.1,\"S1\",null],[[true,false,null],[1,2,null],[0.1,0.2,null],[\"S1\",\"S2\",null],[null,null,null],[],[true,1,0.1,\"S1\",null],[[true,false,null],[1,2,null],[0.1,0.2,null],[\"S1\",\"S2\",null],[null,null,null],[],[true,1,0.1,\"S1\",null]]]]}\n{\"timestamp\":\"2022-02-01T00:00:00\",\"a_bool\":[null,false,true],\"a_int\":[null,2,1],\"a_float\":[null,0.2,0.1],\"a_str\":[null,\"S2\",\"S1\"],\"a_null\":[null,null,null],\"a_empty\":[],\"a_mixed\":[null,\"S1\",0.1,1,true],\"a_nested\":[[null,false,true],[null,2,1],[null,0.2,0.1],[null,\"S2\",\"S1\"],[null,null,null],[],[null,\"S1\",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,\"S2\",\"S1\"],[null,null,null],[],[null,\"S1\",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,\"S2\",\"S1\"],[null,null,null],[],[null,\"S1\",0.1,1,true]]]]}\n{\"timestamp\":\"2022-02-01T00:00:00\",\"a_bool\":[null,false,true],\"a_int\":[null,2,1],\"a_float\":[null,0.2,0.1],\"a_str\":[null,\"S2\",\"S1\"],\"a_null\":[null,null,null],\"a_empty\":[],\"a_mixed\":[null,\"S1\",0.1,1,true],\"a_nested\":[[null,false,true],[null,2,1],[null,0.2,0.1],[null,\"S2\",\"S1\"],[null,null,null],[],[null,\"S1\",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,\"S2\",\"S1\"],[null,null,null],[],[null,\"S1\",0.1,1,true],[[null,false,true],[null,2,1],[null,0.2,0.1],[null,\"S2\",\"S1\"],[null,null,null],[],[null,\"S1\",0.1,1,true]]]]}\n"
+      },
+      "inputFormat": {
+        "type": "json"
+      },
+      "appendToExisting": false
+    },
+    "tuningConfig": {
+      "type": "index_parallel",
+      "partitionsSpec": {
+        "type": "dynamic",
+        "maxRowsPerSegment": 10000000,
+        "maxTotalRows": 500000000
+      },
+      "maxNumConcurrentSubTasks": 1,
+      "indexSpec": {
+        "stringDictionaryEncoding": {
+          "type": "frontCoded",
+          "bucketSize": 4,
+          "formatVersion": 1
+        }
+      }
+    },
+    "dataSchema": {
+      "dataSource": "test_array",
+      "granularitySpec": {
+        "type": "uniform",
+        "queryGranularity": "NONE",
+        "rollup": false,
+        "segmentGranularity": "MONTH"
+      },
+      "timestampSpec": {
+        "column": "timestamp",
+        "format": "auto"
+      },
+      "dimensionsSpec": {
+        "dimensions": [
+          {
+            "name": "a_bool",
+            "type": "auto"
+          },
+          {
+            "name": "a_int",
+            "type": "auto"
+          },
+          {
+            "name": "a_float",
+            "type": "auto"
+          },
+          {
+            "name": "a_str",
+            "type": "auto"
+          },
+          {
+            "name": "a_null",
+            "type": "auto"
+          },
+          {
+            "name": "a_empty",
+            "type": "auto"
+          },
+          {
+            "name": "a_mixed",
+            "type": "auto"
+          },
+          {
+            "name": "a_nested",
+            "type": "auto"
+          },
+          {
+            "name": "t_bool_scalar1",
+            "type": "auto"
+          },
+          {
+            "name": "t_bool_scalar2",
+            "type": "auto"
+          },
+          {
+            "name": "t_int_scalar1",
+            "type": "auto"
+          },
+          {
+            "name": "t_int_scalar2",
+            "type": "auto"
+          },
+          {
+            "name": "t_float_scalar1",
+            "type": "auto"
+          },
+          {
+            "name": "t_float_scalar2",
+            "type": "auto"
+          },
+          {
+            "name": "t_str_scalar1",
+            "type": "auto"
+          },
+          {
+            "name": "t_str_scalar2",
+            "type": "auto"
+          },
+          {
+            "name": "t_null_scalar1",
+            "type": "auto"
+          },
+          {
+            "name": "t_null_scalar2",
+            "type": "auto"
+          },
+          {
+            "name": "t_empty_scalar1",
+            "type": "auto"
+          },
+          {
+            "name": "t_empty_scalar2",
+            "type": "auto"
+          },
+          {
+            "name": "t_mixed_scalar1",
+            "type": "auto"
+          },
+          {
+            "name": "t_mixed_scalar2",
+            "type": "auto"
+          }
+        ]
+      },
+      "metricsSpec": [
+        {
+          "name": "cnt",
+          "type": "count"
+        }
+      ],
+      "transformSpec": {
+        "transforms": [
+          {
+            "type": "expression",
+            "name": "t_bool_scalar1",
+            "expression": "json_value(a_bool, '$[0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_bool_scalar2",
+            "expression": "json_value(a_nested, '$[0][0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_int_scalar1",
+            "expression": "json_value(a_int, '$[0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_int_scalar2",
+            "expression": "json_value(a_nested, '$[1][0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_float_scalar1",
+            "expression": "json_value(a_float, '$[0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_float_scalar2",
+            "expression": "json_value(a_nested, '$[2][0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_str_scalar1",
+            "expression": "json_value(a_str, '$[0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_str_scalar2",
+            "expression": "json_value(a_nested, '$[3][0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_null_scalar1",
+            "expression": "json_value(a_null, '$[0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_null_scalar2",
+            "expression": "json_value(a_nested, '$[4][0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_empty_scalar1",
+            "expression": "json_value(a_empty, '$[0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_empty_scalar2",
+            "expression": "json_value(a_nested, '$[5][0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_mixed_scalar1",
+            "expression": "json_value(a_mixed, '$[0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_mixed_scalar2",
+            "expression": "json_value(a_nested, '$[6][0]')"
+          }
+        ]
+      }
+    }
+  },
+  "context": null
+}
+
diff --git a/sql/src/test/quidem/qatests/qaJsonCols/funcs_and_sql/ingest.json b/sql/src/test/quidem/qatests/qaJsonCols/funcs_and_sql/ingest.json
new file mode 100644
index 000000000000..0077d7e2bd04
--- /dev/null
+++ b/sql/src/test/quidem/qatests/qaJsonCols/funcs_and_sql/ingest.json
@@ -0,0 +1,242 @@
+{
+  "type": "index_parallel",
+  "spec": {
+    "ioConfig": {
+      "type": "index_parallel",
+      "inputSource": {
+        "type": "inline",
+        "data": "{\"timestamp\":\"2022-01-01T00:00:00\",\"s_str\":\"A\",\"s_num_int\":1,\"s_num_float\":0.1,\"s_bool\":true,\"s_null\":null,\"c_empty_obj\":{},\"c_empty_array\":[],\"c_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"c_empty_array_nested\":[{},[],null],\"c1\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null],\"a_obj\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null],\"a_obj\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},\"a_array\":[{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]}]},\"a_array\":[{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null],\"a_obj\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},\"a_array\":[{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]}]},{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null],\"a_obj\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},\"a_array\":[{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]}]}]},\"c2\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null],\"a_obj\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null],\"a_obj\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},\"a_array\":[{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]}]},\"a_array\":[{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null],\"a_obj\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},\"a_array\":[{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]}]},{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null],\"a_obj\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},\"a_array\":[{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]}]}]}}\n{\"timestamp\":\"2022-01-01T00:00:00\",\"s_str\":\"A\",\"s_num_int\":1,\"s_num_float\":0.1,\"s_bool\":true,\"s_null\":null,\"c_empty_obj\":{},\"c_empty_array\":[],\"c_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"c_empty_array_nested\":[{},[],null],\"c1\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null],\"a_obj\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null],\"a_obj\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},\"a_array\":[{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]}]},\"a_array\":[{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null],\"a_obj\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},\"a_array\":[{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]}]},{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null],\"a_obj\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},\"a_array\":[{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]}]}]},\"c2\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null],\"a_obj\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null],\"a_obj\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},\"a_array\":[{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]}]},\"a_array\":[{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null],\"a_obj\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},\"a_array\":[{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]}]},{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null],\"a_obj\":{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},\"a_array\":[{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]},{\"a_str\":\"A\",\"a_num_int\":1,\"a_num_float\":0.1,\"a_bool\":true,\"a_null\":null,\"a_empty_obj\":{},\"a_empty_array\":[],\"a_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"a_empty_array_nested\":[{},[],null]}]}]}}\n{\"timestamp\":\"2022-02-01T00:00:00\",\"s_str\":null,\"s_num_int\":null,\"s_num_float\":null,\"s_bool\":null,\"s_null\":null,\"c_empty_obj\":null,\"c_empty_array\":null,\"c_empty_obj_nested\":null,\"c_empty_array_nested\":null,\"c1\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null],\"b_obj\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null],\"b_obj\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},\"b_array\":[{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]}]},\"b_array\":[{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null],\"b_obj\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},\"b_array\":[{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]}]},{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null],\"b_obj\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},\"b_array\":[{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]}]}]},\"c2\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null],\"b_obj\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null],\"b_obj\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},\"b_array\":[{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]}]},\"b_array\":[{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null],\"b_obj\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},\"b_array\":[{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]}]},{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null],\"b_obj\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},\"b_array\":[{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]}]}]}}\n{\"timestamp\":\"2022-02-01T00:00:00\",\"s_str\":null,\"s_num_int\":null,\"s_num_float\":null,\"s_bool\":null,\"s_null\":null,\"c_empty_obj\":null,\"c_empty_array\":null,\"c_empty_obj_nested\":null,\"c_empty_array_nested\":null,\"c1\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null],\"b_obj\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null],\"b_obj\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},\"b_array\":[{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]}]},\"b_array\":[{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null],\"b_obj\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},\"b_array\":[{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]}]},{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null],\"b_obj\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},\"b_array\":[{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]}]}]},\"c2\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null],\"b_obj\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null],\"b_obj\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},\"b_array\":[{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]}]},\"b_array\":[{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null],\"b_obj\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},\"b_array\":[{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]}]},{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null],\"b_obj\":{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},\"b_array\":[{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]},{\"b_str\":\"A\",\"b_num_int\":1,\"b_num_float\":0.1,\"b_bool\":true,\"b_null\":null,\"b_empty_obj\":{},\"b_empty_array\":[],\"b_empty_obj_nested\":{\"o1\":{},\"o2\":[],\"o3\":null},\"b_empty_array_nested\":[{},[],null]}]}]}}\n"
+      },
+      "inputFormat": {
+        "type": "json"
+      },
+      "appendToExisting": false
+    },
+    "tuningConfig": {
+      "type": "index_parallel",
+      "partitionsSpec": {
+        "type": "dynamic",
+        "maxRowsPerSegment": 100,
+        "maxTotalRows": 100
+      },
+      "maxNumConcurrentSubTasks": 2,
+      "indexSpec": {
+        "stringDictionaryEncoding": {
+          "type": "frontCoded",
+          "bucketSize": 4,
+          "formatVersion": 1
+        }
+      }
+    },
+    "dataSchema": {
+      "dataSource": "test_json_cols",
+      "granularitySpec": {
+        "segmentGranularity": "month",
+        "queryGranularity": null,
+        "rollup": false
+      },
+      "timestampSpec": {
+        "column": "timestamp",
+        "format": "auto"
+      },
+      "dimensionsSpec": {
+        "dimensions": [
+          {
+            "name": "s_str",
+            "type": "auto"
+          },
+          {
+            "name": "s_num_int",
+            "type": "auto"
+          },
+          {
+            "name": "s_num_float",
+            "type": "auto"
+          },
+          {
+            "name": "s_bool",
+            "type": "auto"
+          },
+          {
+            "name": "s_null",
+            "type": "auto"
+          },
+          {
+            "name": "c_empty_obj",
+            "type": "auto"
+          },
+          {
+            "name": "c_empty_array",
+            "type": "auto"
+          },
+          {
+            "name": "c_empty_obj_nested",
+            "type": "auto"
+          },
+          {
+            "name": "c_empty_array_nested",
+            "type": "auto"
+          },
+          {
+            "name": "c1",
+            "type": "auto"
+          },
+          {
+            "name": "c2",
+            "type": "auto"
+          },
+          {
+            "name": "t_obj",
+            "type": "auto"
+          },
+          {
+            "name": "t_array",
+            "type": "auto"
+          },
+          {
+            "name": "t_str1",
+            "type": "auto"
+          },
+          {
+            "name": "t_num_int1",
+            "type": "auto"
+          },
+          {
+            "name": "t_num_float1",
+            "type": "auto"
+          },
+          {
+            "name": "t_bool1",
+            "type": "auto"
+          },
+          {
+            "name": "t_null1",
+            "type": "auto"
+          },
+          {
+            "name": "t_empty_obj",
+            "type": "auto"
+          },
+          {
+            "name": "t_empty_array",
+            "type": "auto"
+          },
+          {
+            "name": "t_str2",
+            "type": "auto"
+          },
+          {
+            "name": "t_num_int2",
+            "type": "long"
+          },
+          {
+            "name": "t_num_float2",
+            "type": "auto"
+          },
+          {
+            "name": "t_bool2",
+            "type": "auto"
+          },
+          {
+            "name": "t_null2",
+            "type": "auto"
+          },
+          {
+            "name": "t_new",
+            "type": "auto"
+          }
+        ]
+      },
+      "metricsSpec": [
+        {
+          "name": "cnt",
+          "type": "count"
+        }
+      ],
+      "transformSpec": {
+        "transforms": [
+          {
+            "type": "expression",
+            "name": "t_obj",
+            "expression": "parse_json(to_json_string(json_query(c1, '$.a_obj')))"
+          },
+          {
+            "type": "expression",
+            "name": "t_array",
+            "expression": "json_query(c1, '$.a_array[0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_str1",
+            "expression": "json_query(s_str, '$.')"
+          },
+          {
+            "type": "expression",
+            "name": "t_num_int1",
+            "expression": "json_query(s_num_int, '$.')"
+          },
+          {
+            "type": "expression",
+            "name": "t_num_float1",
+            "expression": "json_query(s_num_float, '$.')"
+          },
+          {
+            "type": "expression",
+            "name": "t_bool1",
+            "expression": "json_query(s_bool, '$.')"
+          },
+          {
+            "type": "expression",
+            "name": "t_null1",
+            "expression": "json_query(s_null, '$.')"
+          },
+          {
+            "type": "expression",
+            "name": "t_empty_obj",
+            "expression": "json_query(c_empty_array_nested, '$[0]')"
+          },
+          {
+            "type": "expression",
+            "name": "t_empty_array",
+            "expression": "json_query(c_empty_obj_nested, '$.o2')"
+          },
+          {
+            "type": "expression",
+            "name": "t_str2",
+            "expression": "json_query(c1, '$.a_str')"
+          },
+          {
+            "type": "expression",
+            "name": "t_num_int2",
+            "expression": "json_query(c1, '$.a_obj.a_num_int')"
+          },
+          {
+            "type": "expression",
+            "name": "t_num_float2",
+            "expression": "json_query(c1, '$.a_array[0].a_num_float')"
+          },
+          {
+            "type": "expression",
+            "name": "t_bool2",
+            "expression": "json_query(c1, '$.a_array[1].a_bool')"
+          },
+          {
+            "type": "expression",
+            "name": "t_null2",
+            "expression": "json_query(c1, '$.a_null')"
+          },
+          {
+            "type": "expression",
+            "name": "t_new",
+            "expression": "json_object('c1', c1, 'c2', c2)"
+          }
+        ]
+      }
+    }
+  },
+  "context": {
+    "storeEmptyColumns": true
+  }
+}
+
+

From 1b2b242b9f8ef957c8e9b794f57b8053c5f8bcb1 Mon Sep 17 00:00:00 2001
From: Adarsh Sanjeev <adarshsanjeev@gmail.com>
Date: Fri, 28 Mar 2025 14:50:10 +0530
Subject: [PATCH 64/99] Optionally include Content-Disposition header in
 statement results API response (#17840)

Adds support for an optional filename query parameter to the /druid/v2/sql/statements/{queryId}/results API. When provided, the response will include a header Content-Disposition: attachment; filename="{filename}", which will instruct a web browser to save the response as a file rather than displaying it inline.

This save-as-attachment behavior could be achieved by adding a "download" attribute to the results link, but this only works for same-origin URLs (as in the Web Console). If the UI origin is different from the Druid API origin, browsers will ignore the attribute and serve the results inline, which is poor UX for files that are potentially very large.

For the sake of consistency, all successful responses in SqlStatementResource.doGetResults may include this header, even if there are no results.
Release note

Improved: The "Get query results" statements API supports an optional filename query parameter. When provided, the response will instruct web browsers to save the results as a file instead of showing them inline (via the Content-Disposition header).
---
 docs/api-reference/sql-api.md                 |   3 +
 .../sql/resources/SqlStatementResource.java   |  53 ++++++-
 .../SqlMSQStatementResourcePostTest.java      |  15 ++
 .../resources/SqlStatementResourceTest.java   | 135 ++++++++++++++++--
 4 files changed, 190 insertions(+), 16 deletions(-)

diff --git a/docs/api-reference/sql-api.md b/docs/api-reference/sql-api.md
index 2b25bdd02f0b..ccba5b154355 100644
--- a/docs/api-reference/sql-api.md
+++ b/docs/api-reference/sql-api.md
@@ -1286,6 +1286,9 @@ Getting the query results for an ingestion query returns an empty response.
 * `resultFormat` (optional)
     * Type: String
     * Defines the format in which the results are presented. The following options are supported `arrayLines`,`objectLines`,`array`,`object`, and `csv`. The default is `object`.
+* `filename` (optional)
+    * Type: String  
+    * If set, attaches a `Content-Disposition` header to the response with the value of `attachment; filename={filename}`. The filename must not be longer than 255 characters and must not contain the characters `/`, `\`, `:`, `*`, `?`, `"`, `<`, `>`, `|`, `\0`, `\n`, or `\r`.
 
 #### Responses
 
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/resources/SqlStatementResource.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/resources/SqlStatementResource.java
index dcaa447539b1..f0a800c246ab 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/resources/SqlStatementResource.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/resources/SqlStatementResource.java
@@ -95,6 +95,7 @@
 import org.jboss.netty.handler.codec.http.HttpResponseStatus;
 
 import javax.servlet.http.HttpServletRequest;
+import javax.validation.constraints.NotNull;
 import javax.ws.rs.Consumes;
 import javax.ws.rs.DELETE;
 import javax.ws.rs.GET;
@@ -114,6 +115,7 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
 
@@ -122,6 +124,8 @@ public class SqlStatementResource
 {
 
   public static final String RESULT_FORMAT = "__resultFormat";
+  public static final String CONTENT_DISPOSITION_RESPONSE_HEADER = "Content-Disposition";
+  private static final Pattern FILENAME_PATTERN = Pattern.compile("^[^/:*?><\\\\\"|\0\n\r]*$");
   private static final Logger log = new Logger(SqlStatementResource.class);
   private final SqlStatementFactory msqSqlStatementFactory;
   private final ObjectMapper jsonMapper;
@@ -277,6 +281,7 @@ public Response doGetResults(
       @PathParam("id") final String queryId,
       @QueryParam("page") Long page,
       @QueryParam("resultFormat") String resultFormat,
+      @QueryParam("filename") String filename,
       @Context final HttpServletRequest req
   )
   {
@@ -309,10 +314,12 @@ public Response doGetResults(
       );
       throwIfQueryIsNotSuccessful(queryId, statusPlus);
 
+      final String contentDispositionHeaderValue = filename != null ? StringUtils.format("attachment; filename=\"%s\"", validateFilename(filename)) : null;
+
       Optional<List<ColumnNameAndTypes>> signature = SqlStatementResourceHelper.getSignature(msqControllerTask);
       if (!signature.isPresent() || MSQControllerTask.isIngestion(msqControllerTask.getQuerySpec())) {
         // Since it's not a select query, nothing to return.
-        return Response.ok().build();
+        return addContentDisposition(Response.ok(), contentDispositionHeaderValue).build();
       }
 
       // returning results
@@ -321,18 +328,20 @@ public Response doGetResults(
       results = getResultYielder(queryId, page, msqControllerTask, closer);
       if (!results.isPresent()) {
         // no results, return empty
-        return Response.ok().build();
+        return addContentDisposition(Response.ok(), contentDispositionHeaderValue).build();
       }
 
       ResultFormat preferredFormat = getPreferredResultFormat(resultFormat, msqControllerTask.getQuerySpec());
-      return Response.ok((StreamingOutput) outputStream -> resultPusher(
+      final Response.ResponseBuilder responseBuilder = Response.ok((StreamingOutput) outputStream -> resultPusher(
           queryId,
           signature,
           closer,
           results,
           new CountingOutputStream(outputStream),
           preferredFormat
-      )).build();
+      ));
+
+      return addContentDisposition(responseBuilder, contentDispositionHeaderValue).build();
     }
 
 
@@ -976,6 +985,42 @@ private void checkForDurableStorageConnectorImpl()
     }
   }
 
+  private static Response.ResponseBuilder addContentDisposition(
+      Response.ResponseBuilder responseBuilder,
+      String contentDisposition
+  )
+  {
+    if (contentDisposition != null) {
+      responseBuilder.header(CONTENT_DISPOSITION_RESPONSE_HEADER, contentDisposition);
+    }
+    return responseBuilder;
+  }
+
+  /**
+   * Validates that a filename is valid. Filenames are considered to be valid if it is:
+   * <ul>
+   *   <li>Not empty.</li>
+   *   <li>Not longer than 255 characters.</li>
+   *   <li>Does not contain the characters `/`, `\`, `:`, `*`, `?`, `"`, `<`, `>`, `|`, `\0`, `\n`, or `\r`.</li>
+   * </ul>
+   */
+  @VisibleForTesting
+  static String validateFilename(@NotNull String filename)
+  {
+    if (filename.isEmpty()) {
+      throw InvalidInput.exception("Filename cannot be empty.");
+    }
+
+    if (filename.length() > 255) {
+      throw InvalidInput.exception("Filename cannot be longer than 255 characters.");
+    }
+
+    if (!FILENAME_PATTERN.matcher(filename).matches()) {
+      throw InvalidInput.exception("Filename contains invalid characters. (/, \\, :, *, ?, \", <, >, |, \0, \n, or \r)");
+    }
+    return filename;
+  }
+
   private <T> T contactOverlord(final ListenableFuture<T> future, String queryId)
   {
     try {
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/resources/SqlMSQStatementResourcePostTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/resources/SqlMSQStatementResourcePostTest.java
index e810de56f4e1..0437fbccda25 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/resources/SqlMSQStatementResourcePostTest.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/resources/SqlMSQStatementResourcePostTest.java
@@ -393,6 +393,7 @@ public void testWithDurableStorage() throws IOException
             sqlStatementResult.getQueryId(),
             null,
             ResultFormat.OBJECTLINES.name(),
+            null,
             SqlStatementResourceTest.makeOkRequest()
         ),
         objectMapper
@@ -406,6 +407,7 @@ public void testWithDurableStorage() throws IOException
             sqlStatementResult.getQueryId(),
             0L,
             ResultFormat.OBJECTLINES.name(),
+            null,
             SqlStatementResourceTest.makeOkRequest()
         ),
         objectMapper
@@ -419,6 +421,7 @@ public void testWithDurableStorage() throws IOException
             sqlStatementResult.getQueryId(),
             2L,
             ResultFormat.OBJECTLINES.name(),
+            null,
             SqlStatementResourceTest.makeOkRequest()
         ),
         objectMapper
@@ -485,6 +488,7 @@ public void testMultipleWorkersWithPageSizeLimiting() throws IOException
         sqlStatementResult.getQueryId(),
         null,
         ResultFormat.ARRAY.name(),
+        null,
         SqlStatementResourceTest.makeOkRequest()
     )));
 
@@ -492,6 +496,7 @@ public void testMultipleWorkersWithPageSizeLimiting() throws IOException
         sqlStatementResult.getQueryId(),
         0L,
         ResultFormat.ARRAY.name(),
+        null,
         SqlStatementResourceTest.makeOkRequest()
     )));
 
@@ -499,6 +504,7 @@ public void testMultipleWorkersWithPageSizeLimiting() throws IOException
         sqlStatementResult.getQueryId(),
         1L,
         ResultFormat.ARRAY.name(),
+        null,
         SqlStatementResourceTest.makeOkRequest()
     )));
 
@@ -506,6 +512,7 @@ public void testMultipleWorkersWithPageSizeLimiting() throws IOException
         sqlStatementResult.getQueryId(),
         2L,
         ResultFormat.ARRAY.name(),
+        null,
         SqlStatementResourceTest.makeOkRequest()
     )));
 
@@ -513,6 +520,7 @@ public void testMultipleWorkersWithPageSizeLimiting() throws IOException
         sqlStatementResult.getQueryId(),
         3L,
         ResultFormat.ARRAY.name(),
+        null,
         SqlStatementResourceTest.makeOkRequest()
     )));
 
@@ -520,6 +528,7 @@ public void testMultipleWorkersWithPageSizeLimiting() throws IOException
         sqlStatementResult.getQueryId(),
         4L,
         ResultFormat.ARRAY.name(),
+        null,
         SqlStatementResourceTest.makeOkRequest()
     )));
   }
@@ -565,6 +574,7 @@ public void testResultFormat() throws Exception
                   sqlStatementResult.getQueryId(),
                   null,
                   resultFormat.name(),
+                  null,
                   SqlStatementResourceTest.makeOkRequest()
               ), objectMapper
           )
@@ -577,6 +587,7 @@ public void testResultFormat() throws Exception
                   sqlStatementResult.getQueryId(),
                   0L,
                   resultFormat.name(),
+                  null,
                   SqlStatementResourceTest.makeOkRequest()
               ), objectMapper
           )
@@ -616,6 +627,7 @@ public void testResultFormatWithParamInSelect() throws IOException
         sqlStatementResult.getQueryId(),
         null,
         ResultFormat.ARRAY.name(),
+        null,
         SqlStatementResourceTest.makeOkRequest()
     )));
 
@@ -623,6 +635,7 @@ public void testResultFormatWithParamInSelect() throws IOException
         sqlStatementResult.getQueryId(),
         0L,
         ResultFormat.ARRAY.name(),
+        null,
         SqlStatementResourceTest.makeOkRequest()
     )));
   }
@@ -695,6 +708,7 @@ public void testInsert()
         actual.getQueryId(),
         0L,
         null,
+        null,
         SqlStatementResourceTest.makeOkRequest()
     );
     Assert.assertEquals(Response.Status.OK.getStatusCode(), resultsResponse.getStatus());
@@ -738,6 +752,7 @@ public void testReplaceAll()
         actual.getQueryId(),
         0L,
         null,
+        null,
         SqlStatementResourceTest.makeOkRequest()
     );
     Assert.assertEquals(Response.Status.OK.getStatusCode(), resultsResponse.getStatus());
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/resources/SqlStatementResourceTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/resources/SqlStatementResourceTest.java
index 40dcb303b1dc..83ae1de7f9d3 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/resources/SqlStatementResourceTest.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/resources/SqlStatementResourceTest.java
@@ -22,11 +22,14 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.SettableFuture;
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.druid.client.indexing.TaskPayloadResponse;
 import org.apache.druid.client.indexing.TaskStatusResponse;
+import org.apache.druid.error.DruidException;
+import org.apache.druid.error.DruidExceptionMatcher;
 import org.apache.druid.error.ErrorResponse;
 import org.apache.druid.indexer.TaskLocation;
 import org.apache.druid.indexer.TaskState;
@@ -92,6 +95,7 @@
 import org.mockito.Mock;
 import org.mockito.Mockito;
 
+import javax.annotation.Nullable;
 import javax.ws.rs.core.Response;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
@@ -102,6 +106,8 @@
 import java.util.List;
 import java.util.function.Supplier;
 
+import static org.hamcrest.MatcherAssert.assertThat;
+
 public class SqlStatementResourceTest extends MSQTestBase
 {
   public static final DateTime CREATED_TIME = DateTimes.of("2023-05-31T12:00Z");
@@ -683,6 +689,16 @@ private static AuthenticationResult makeAuthResultForUser(String user)
     );
   }
 
+  @Nullable
+  private Object getHeader(Response resp, String header)
+  {
+    final List<Object> objects = resp.getMetadata().get(header);
+    if (objects == null) {
+      return null;
+    }
+    return Iterables.getOnlyElement(objects);
+  }
+
   @BeforeEach
   public void init()
   {
@@ -716,7 +732,7 @@ public void testMSQSelectAcceptedQuery()
     );
 
     assertExceptionMessage(
-        resource.doGetResults(ACCEPTED_SELECT_MSQ_QUERY, 0L, null, makeOkRequest()),
+        resource.doGetResults(ACCEPTED_SELECT_MSQ_QUERY, 0L, null, null, makeOkRequest()),
         StringUtils.format(
             "Query[%s] is currently in [%s] state. Please wait for it to complete.",
             ACCEPTED_SELECT_MSQ_QUERY,
@@ -750,7 +766,7 @@ public void testMSQSelectRunningQuery()
     );
 
     assertExceptionMessage(
-        resource.doGetResults(RUNNING_SELECT_MSQ_QUERY, 0L, null, makeOkRequest()),
+        resource.doGetResults(RUNNING_SELECT_MSQ_QUERY, 0L, null, null, makeOkRequest()),
         StringUtils.format(
             "Query[%s] is currently in [%s] state. Please wait for it to complete.",
             RUNNING_SELECT_MSQ_QUERY,
@@ -816,7 +832,7 @@ public void testFinishedSelectMSQQuery() throws Exception
         null
     )), objectMapper.writeValueAsString(response.getEntity()));
 
-    Response resultsResponse = resource.doGetResults(FINISHED_SELECT_MSQ_QUERY, 0L, ResultFormat.OBJECTLINES.name(), makeOkRequest());
+    Response resultsResponse = resource.doGetResults(FINISHED_SELECT_MSQ_QUERY, 0L, ResultFormat.OBJECTLINES.name(), null, makeOkRequest());
     Assert.assertEquals(Response.Status.OK.getStatusCode(), resultsResponse.getStatus());
 
     String expectedResult = "{\"_time\":123,\"alias\":\"foo\",\"market\":\"bar\"}\n"
@@ -824,6 +840,8 @@ public void testFinishedSelectMSQQuery() throws Exception
 
     assertExpectedResults(expectedResult, resultsResponse);
 
+    Assert.assertNull(getHeader(resultsResponse, SqlStatementResource.CONTENT_DISPOSITION_RESPONSE_HEADER));
+
     Assert.assertEquals(
         Response.Status.OK.getStatusCode(),
         resource.deleteQuery(FINISHED_SELECT_MSQ_QUERY, makeOkRequest()).getStatus()
@@ -835,6 +853,7 @@ public void testFinishedSelectMSQQuery() throws Exception
             FINISHED_SELECT_MSQ_QUERY,
             0L,
             ResultFormat.OBJECTLINES.name(),
+            null,
             makeOkRequest()
         )
     );
@@ -845,14 +864,50 @@ public void testFinishedSelectMSQQuery() throws Exception
             FINISHED_SELECT_MSQ_QUERY,
             null,
             ResultFormat.OBJECTLINES.name(),
+            null,
             makeOkRequest()
         )
     );
 
     Assert.assertEquals(
         Response.Status.BAD_REQUEST.getStatusCode(),
-        resource.doGetResults(FINISHED_SELECT_MSQ_QUERY, -1L, null, makeOkRequest()).getStatus()
+        resource.doGetResults(FINISHED_SELECT_MSQ_QUERY, -1L, null, null, makeOkRequest()).getStatus()
+    );
+
+    Assert.assertEquals(
+        "attachment; filename=\"my-file.ndjson\"",
+        getHeader(
+            resource.doGetResults(FINISHED_SELECT_MSQ_QUERY, 0L, ResultFormat.OBJECTLINES.name(), "my-file.ndjson", makeOkRequest()),
+            SqlStatementResource.CONTENT_DISPOSITION_RESPONSE_HEADER
+        )
+    );
+  }
+
+  @Test
+  public void testDownloadResultsAsFile() throws Exception
+  {
+    final String expectedResult = "{\"_time\":123,\"alias\":\"foo\",\"market\":\"bar\"}\n"
+                                  + "{\"_time\":234,\"alias\":\"foo1\",\"market\":\"bar1\"}\n\n";
+
+    Response resultsResponse1 = resource.doGetResults(FINISHED_SELECT_MSQ_QUERY, 0L, ResultFormat.OBJECTLINES.name(), "results.txt", makeOkRequest());
+    Assert.assertEquals(Response.Status.OK.getStatusCode(), resultsResponse1.getStatus());
+    Assert.assertEquals(
+        "attachment; filename=\"results.txt\"",
+        getHeader(resultsResponse1, "Content-Disposition")
+    );
+    assertExpectedResults(expectedResult, resultsResponse1);
+
+    Response resultsResponse2 = resource.doGetResults(FINISHED_SELECT_MSQ_QUERY, 0L, ResultFormat.OBJECTLINES.name(), "final results.txt", makeOkRequest());
+    Assert.assertEquals(Response.Status.OK.getStatusCode(), resultsResponse2.getStatus());
+    Assert.assertEquals(
+        "attachment; filename=\"final results.txt\"",
+        getHeader(resultsResponse2, "Content-Disposition")
     );
+    assertExpectedResults(expectedResult, resultsResponse2);
+
+    Response resultsResponse3 = resource.doGetResults(FINISHED_SELECT_MSQ_QUERY, 0L, ResultFormat.OBJECTLINES.name(), "/Users/Name/final.txt", makeOkRequest());
+    Assert.assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), resultsResponse3.getStatus());
+    Assert.assertNull(resultsResponse3.getMetadata().get("Content-Disposition"));
   }
 
   private void assertExpectedResults(String expectedResult, Response resultsResponse) throws IOException
@@ -867,7 +922,7 @@ public void testFailedMSQQuery()
     for (String queryID : ImmutableList.of(ERRORED_SELECT_MSQ_QUERY, ERRORED_INSERT_MSQ_QUERY)) {
       assertExceptionMessage(resource.doGetStatus(queryID, false, makeOkRequest()), FAILURE_MSG, Response.Status.OK);
       assertExceptionMessage(
-          resource.doGetResults(queryID, 0L, null, makeOkRequest()),
+          resource.doGetResults(queryID, 0L, null, null, makeOkRequest()),
           StringUtils.format(
               "Query[%s] failed. Check the status api for more details.",
               queryID
@@ -897,18 +952,29 @@ public void testFinishedInsertMSQQuery()
         null
     ), (SqlStatementResult) response.getEntity());
 
+    final Response resultResponse = resource.doGetResults(FINISHED_INSERT_MSQ_QUERY, 0L, null, null, makeOkRequest());
+
     Assert.assertEquals(
         Response.Status.OK.getStatusCode(),
-        resource.doGetResults(FINISHED_INSERT_MSQ_QUERY, 0L, null, makeOkRequest()).getStatus()
+        resultResponse.getStatus()
     );
+    Assert.assertNull(getHeader(resultResponse, SqlStatementResource.CONTENT_DISPOSITION_RESPONSE_HEADER));
     Assert.assertEquals(
         Response.Status.OK.getStatusCode(),
-        resource.doGetResults(FINISHED_INSERT_MSQ_QUERY, null, null, makeOkRequest()).getStatus()
+        resource.doGetResults(FINISHED_INSERT_MSQ_QUERY, null, null, null, makeOkRequest()).getStatus()
     );
 
     Assert.assertEquals(
         Response.Status.BAD_REQUEST.getStatusCode(),
-        resource.doGetResults(FINISHED_INSERT_MSQ_QUERY, -1L, null, makeOkRequest()).getStatus()
+        resource.doGetResults(FINISHED_INSERT_MSQ_QUERY, -1L, null, null, makeOkRequest()).getStatus()
+    );
+
+    Assert.assertEquals(
+        "attachment; filename=\"my-file.ndjson\"",
+        getHeader(
+            resource.doGetResults(FINISHED_INSERT_MSQ_QUERY, 0L, null, "my-file.ndjson", makeOkRequest()),
+            SqlStatementResource.CONTENT_DISPOSITION_RESPONSE_HEADER
+        )
     );
   }
 
@@ -917,7 +983,7 @@ public void testNonMSQTasks()
   {
     for (String queryID : ImmutableList.of(RUNNING_NON_MSQ_TASK, FAILED_NON_MSQ_TASK, FINISHED_NON_MSQ_TASK)) {
       assertNotFound(resource.doGetStatus(queryID, false, makeOkRequest()), queryID);
-      assertNotFound(resource.doGetResults(queryID, 0L, null, makeOkRequest()), queryID);
+      assertNotFound(resource.doGetResults(queryID, 0L, null, null, makeOkRequest()), queryID);
       assertNotFound(resource.deleteQuery(queryID, makeOkRequest()), queryID);
     }
   }
@@ -941,7 +1007,7 @@ public void testMSQInsertAcceptedQuery()
     );
 
     assertExceptionMessage(
-        resource.doGetResults(ACCEPTED_INSERT_MSQ_TASK, 0L, null, makeOkRequest()),
+        resource.doGetResults(ACCEPTED_INSERT_MSQ_TASK, 0L, null, null, makeOkRequest()),
         StringUtils.format(
             "Query[%s] is currently in [%s] state. Please wait for it to complete.",
             ACCEPTED_INSERT_MSQ_TASK,
@@ -974,7 +1040,7 @@ public void testMSQInsertRunningQuery()
     );
 
     assertExceptionMessage(
-        resource.doGetResults(RUNNING_INSERT_MSQ_QUERY, 0L, null, makeOkRequest()),
+        resource.doGetResults(RUNNING_INSERT_MSQ_QUERY, 0L, null, null, makeOkRequest()),
         StringUtils.format(
             "Query[%s] is currently in [%s] state. Please wait for it to complete.",
             RUNNING_INSERT_MSQ_QUERY,
@@ -1005,6 +1071,7 @@ public void testAPIBehaviourWithSuperUsers()
             RUNNING_SELECT_MSQ_QUERY,
             1L,
             null,
+            null,
             makeExpectedReq(makeAuthResultForUser(SUPERUSER))
         ).getStatus()
     );
@@ -1035,6 +1102,7 @@ public void testAPIBehaviourWithDifferentUserAndNoStatePermission()
             RUNNING_SELECT_MSQ_QUERY,
             1L,
             null,
+            null,
             makeExpectedReq(differentUserAuthResult)
         ).getStatus()
     );
@@ -1065,6 +1133,7 @@ public void testAPIBehaviourWithDifferentUserAndStateRPermission()
             RUNNING_SELECT_MSQ_QUERY,
             1L,
             null,
+            null,
             makeExpectedReq(differentUserAuthResult)
         ).getStatus()
     );
@@ -1095,6 +1164,7 @@ public void testAPIBehaviourWithDifferentUserAndStateWPermission()
             RUNNING_SELECT_MSQ_QUERY,
             1L,
             null,
+            null,
             makeExpectedReq(differentUserAuthResult)
         ).getStatus()
     );
@@ -1125,6 +1195,7 @@ public void testAPIBehaviourWithDifferentUserAndStateRWPermission()
             RUNNING_SELECT_MSQ_QUERY,
             1L,
             null,
+            null,
             makeExpectedReq(differentUserAuthResult)
         ).getStatus()
     );
@@ -1156,7 +1227,7 @@ public void testTaskIdNotFound()
     );
     Assert.assertEquals(
         Response.Status.NOT_FOUND.getStatusCode(),
-        resource.doGetResults(taskIdNotFound, null, null, makeOkRequest()).getStatus()
+        resource.doGetResults(taskIdNotFound, null, null, null, makeOkRequest()).getStatus()
     );
     Assert.assertEquals(
         Response.Status.NOT_FOUND.getStatusCode(),
@@ -1193,4 +1264,44 @@ private void assertSqlStatementResult(SqlStatementResult expected, SqlStatementR
       Assert.assertEquals(expected.getErrorResponse().getAsMap(), actual.getErrorResponse().getAsMap());
     }
   }
+
+  @Test
+  public void testValidFilename()
+  {
+    // Valid cases
+    SqlStatementResource.validateFilename("testname");
+    SqlStatementResource.validateFilename("A.txt");
+    SqlStatementResource.validateFilename("final-results.txt");
+    SqlStatementResource.validateFilename("final results.txt");
+    SqlStatementResource.validateFilename("final;results.txt");
+    SqlStatementResource.validateFilename("final@results.txt");
+
+    // Empty
+    assertInvalidFileName("", "Filename cannot be empty.");
+
+    // Too long
+    assertInvalidFileName(StringUtils.repeat("A", 300), "Filename cannot be longer than 255 characters.");
+
+    // Special characters
+    assertInvalidFileName("He\\llo", "Filename contains invalid characters. (/, \\, :, *, ?, \", <, >, |, \0, \n, or \r)");
+    assertInvalidFileName("Hello/Name", "Filename contains invalid characters. (/, \\, :, *, ?, \", <, >, |, \0, \n, or \r)");
+    assertInvalidFileName("C:/Users/Name", "Filename contains invalid characters. (/, \\, :, *, ?, \", <, >, |, \0, \n, or \r)");
+    assertInvalidFileName("username:password", "Filename contains invalid characters. (/, \\, :, *, ?, \", <, >, |, \0, \n, or \r)");
+    assertInvalidFileName("A>ValueB", "Filename contains invalid characters. (/, \\, :, *, ?, \", <, >, |, \0, \n, or \r)");
+    assertInvalidFileName("A<ValueB", "Filename contains invalid characters. (/, \\, :, *, ?, \", <, >, |, \0, \n, or \r)");
+    assertInvalidFileName("A\0a11", "Filename contains invalid characters. (/, \\, :, *, ?, \", <, >, |, \0, \n, or \r)");
+    assertInvalidFileName("\rrB", "Filename contains invalid characters. (/, \\, :, *, ?, \", <, >, |, \0, \n, or \r)");
+    assertInvalidFileName("\nAnB", "Filename contains invalid characters. (/, \\, :, *, ?, \", <, >, |, \0, \n, or \r)");
+    assertInvalidFileName("A|B", "Filename contains invalid characters. (/, \\, :, *, ?, \", <, >, |, \0, \n, or \r)");
+    assertInvalidFileName("A\"B", "Filename contains invalid characters. (/, \\, :, *, ?, \", <, >, |, \0, \n, or \r)");
+    assertInvalidFileName("A?B", "Filename contains invalid characters. (/, \\, :, *, ?, \", <, >, |, \0, \n, or \r)");
+  }
+
+  private void assertInvalidFileName(String filename, String errorMessage)
+  {
+    assertThat(
+        Assert.assertThrows(DruidException.class, () -> SqlStatementResource.validateFilename(filename)),
+        DruidExceptionMatcher.invalidInput().expectMessageIs(errorMessage)
+    );
+  }
 }

From 99107772fa964e727f9965489ee7037442484614 Mon Sep 17 00:00:00 2001
From: Vadim Ogievetsky <vadim@ogievetsky.com>
Date: Fri, 28 Mar 2025 19:10:33 -0700
Subject: [PATCH 65/99] Web console: download follow up (#17845)

* set filename

* update download button

* added markdown support

* add test

* better download

* fix TSV

* better download behaviour and tests

* always show download all button
---
 licenses.yaml                                 |  10 ++
 web-console/package-lock.json                 |  12 ++
 web-console/package.json                      |   1 +
 web-console/src/utils/download.spec.ts        | 131 +++++++++++++++--
 web-console/src/utils/download.ts             | 134 ++++++++++--------
 .../destination-pages-pane.tsx                |  42 +++---
 .../execution-summary-panel.tsx               |  87 +++++++-----
 7 files changed, 284 insertions(+), 133 deletions(-)

diff --git a/licenses.yaml b/licenses.yaml
index 8253cdd34881..9b7370e22e13 100644
--- a/licenses.yaml
+++ b/licenses.yaml
@@ -6038,6 +6038,16 @@ license_file_path: licenses/bin/lower-case.MIT
 
 ---
 
+name: "markdown-table-ts"
+license_category: binary
+module: web-console
+license_name: MIT License
+copyright: Jiri Hajek
+version: 1.0.3
+license_file_path: licenses/bin/markdown-table-ts.MIT
+
+---
+
 name: "memoize-one"
 license_category: binary
 module: web-console
diff --git a/web-console/package-lock.json b/web-console/package-lock.json
index 97a1d3e0538e..b36595a9c73e 100644
--- a/web-console/package-lock.json
+++ b/web-console/package-lock.json
@@ -37,6 +37,7 @@
         "json-bigint-native": "^1.2.0",
         "lodash.debounce": "^4.0.8",
         "lodash.escape": "^4.0.1",
+        "markdown-table-ts": "^1.0.3",
         "memoize-one": "^5.2.1",
         "numeral": "^2.0.6",
         "react": "^18.3.1",
@@ -12748,6 +12749,12 @@
         "tmpl": "1.0.5"
       }
     },
+    "node_modules/markdown-table-ts": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/markdown-table-ts/-/markdown-table-ts-1.0.3.tgz",
+      "integrity": "sha512-lYrp7FXmBqpmGmsEF92WnSukdgYvLm15FPIODZOx9+3nobkxJxjBYcszqZf5VqTjBtISPSNC7zjU9o3zwpL6AQ==",
+      "license": "MIT"
+    },
     "node_modules/mathml-tag-names": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/mathml-tag-names/-/mathml-tag-names-2.1.3.tgz",
@@ -27438,6 +27445,11 @@
         "tmpl": "1.0.5"
       }
     },
+    "markdown-table-ts": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/markdown-table-ts/-/markdown-table-ts-1.0.3.tgz",
+      "integrity": "sha512-lYrp7FXmBqpmGmsEF92WnSukdgYvLm15FPIODZOx9+3nobkxJxjBYcszqZf5VqTjBtISPSNC7zjU9o3zwpL6AQ=="
+    },
     "mathml-tag-names": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/mathml-tag-names/-/mathml-tag-names-2.1.3.tgz",
diff --git a/web-console/package.json b/web-console/package.json
index 37e67a7bcd58..789faccd4984 100644
--- a/web-console/package.json
+++ b/web-console/package.json
@@ -78,6 +78,7 @@
     "json-bigint-native": "^1.2.0",
     "lodash.debounce": "^4.0.8",
     "lodash.escape": "^4.0.1",
+    "markdown-table-ts": "^1.0.3",
     "memoize-one": "^5.2.1",
     "numeral": "^2.0.6",
     "react": "^18.3.1",
diff --git a/web-console/src/utils/download.spec.ts b/web-console/src/utils/download.spec.ts
index 71c051500d0d..502d361325e8 100644
--- a/web-console/src/utils/download.spec.ts
+++ b/web-console/src/utils/download.spec.ts
@@ -16,18 +16,129 @@
  * limitations under the License.
  */
 
-import { formatForFormat } from './download';
+import { QueryResult, sane } from 'druid-query-toolkit';
+
+import { queryResultsToString, stringifyCsvValue, stringifyTsvValue } from './download';
 
 describe('download', () => {
-  it('.formatForFormat', () => {
-    expect(formatForFormat(null, 'csv')).toEqual('');
-    expect(formatForFormat(null, 'tsv')).toEqual('');
-    expect(formatForFormat('', 'csv')).toEqual('""');
-    expect(formatForFormat('null', 'csv')).toEqual('"null"');
-    expect(formatForFormat('hello\nworld', 'csv')).toEqual('"hello world"');
-    expect(formatForFormat(123, 'csv')).toEqual('"123"');
-    expect(formatForFormat(new Date('2021-01-02T03:04:05.678Z'), 'csv')).toEqual(
-      '"2021-01-02T03:04:05.678Z"',
+  it('stringifyCsvValue', () => {
+    expect(stringifyCsvValue(null)).toEqual('');
+    expect(stringifyCsvValue('')).toEqual('');
+    expect(stringifyCsvValue('null')).toEqual('null');
+    expect(stringifyCsvValue('hello\nworld')).toEqual('hello world');
+    expect(stringifyCsvValue('Jane "JD" Smith')).toEqual('"Jane ""JD"" Smith"');
+    expect(stringifyCsvValue(123)).toEqual('123');
+    expect(stringifyCsvValue(new Date('2021-01-02T03:04:05.678Z'))).toEqual(
+      '2021-01-02T03:04:05.678Z',
+    );
+  });
+
+  it('stringifyTsvValue', () => {
+    expect(stringifyTsvValue(null)).toEqual('');
+    expect(stringifyTsvValue('')).toEqual('');
+    expect(stringifyTsvValue('null')).toEqual('null');
+    expect(stringifyTsvValue('hello\nworld')).toEqual('hello world');
+    expect(stringifyTsvValue(123)).toEqual('123');
+    expect(stringifyTsvValue(new Date('2021-01-02T03:04:05.678Z'))).toEqual(
+      '2021-01-02T03:04:05.678Z',
     );
   });
+
+  describe('queryResultsToString', () => {
+    /*
+    Data for testing:
+    =================
+    {"name": "John, Doe", "age": 29, "city": "New York", "bio": "Loves coding\nand coffee"}
+    {"name": "Jane \"JD\" Smith", "age": 34, "city": "Los Angeles", "bio": "Enjoys \"live music\" and travel"}
+    {"name": "Michael, O'Connor", "age": 41, "city": "Chicago", "bio": "Expert in AI\\ML"}
+    {"name": "李四 (Li Si)", "age": 27, "city": "北京 (Beijing)", "bio": "喜欢编程和阅读"}
+    {"name": "O'Reilly, Patrick", "age": 45, "city": null, "bio": "\nLoves\ttabs"}
+     */
+
+    const queryResult = QueryResult.fromRawResult(
+      [
+        ['__time', 'name', 'age', 'city', 'bio'],
+        ['LONG', 'STRING', 'LONG', 'STRING', 'STRING'],
+        ['TIMESTAMP', 'VARCHAR', 'BIGINT', 'VARCHAR', 'VARCHAR'],
+        [
+          '1970-01-01T00:00:00.000Z',
+          'Jane "JD" Smith',
+          34,
+          'Los Angeles',
+          'Enjoys "live music" and travel',
+        ],
+        ['1970-01-01T00:00:00.000Z', 'John, Doe', 29, 'New York', 'Loves coding\nand coffee'],
+        ['1970-01-01T00:00:00.000Z', "Michael, O'Connor", 41, 'Chicago', 'Expert in AI\\ML'],
+        ['1970-01-01T00:00:00.000Z', "O'Reilly, Patrick", 45, null, '\nLoves\ttabs'],
+        ['1970-01-01T00:00:00.000Z', '李四 (Li Si)', 27, '北京 (Beijing)', '喜欢编程和阅读'],
+      ],
+      true,
+      true,
+      true,
+      true,
+    );
+
+    it('works with CSV', () => {
+      expect(queryResultsToString(queryResult, 'csv').replaceAll('\t', '\\t')).toEqual(sane`
+        __time,name,age,city,bio
+        1970-01-01T00:00:00.000Z,"Jane ""JD"" Smith",34,Los Angeles,"Enjoys ""live music"" and travel"
+        1970-01-01T00:00:00.000Z,"John, Doe",29,New York,Loves coding and coffee
+        1970-01-01T00:00:00.000Z,"Michael, O'Connor",41,Chicago,Expert in AI\\ML
+        1970-01-01T00:00:00.000Z,"O'Reilly, Patrick",45,," Loves\ttabs"
+        1970-01-01T00:00:00.000Z,李四 (Li Si),27,北京 (Beijing),喜欢编程和阅读
+      `);
+    });
+
+    it('works with TSV', () => {
+      expect(queryResultsToString(queryResult, 'tsv').replaceAll('\t', '\\t')).toEqual(sane`
+        __time\tname\tage\tcity\tbio
+        1970-01-01T00:00:00.000Z\tJane "JD" Smith\t34\tLos Angeles\tEnjoys "live music" and travel
+        1970-01-01T00:00:00.000Z\tJohn, Doe\t29\tNew York\tLoves coding and coffee
+        1970-01-01T00:00:00.000Z\tMichael, O'Connor\t41\tChicago\tExpert in AI\\ML
+        1970-01-01T00:00:00.000Z\tO'Reilly, Patrick\t45\t\t Loves tabs
+        1970-01-01T00:00:00.000Z\t李四 (Li Si)\t27\t北京 (Beijing)\t喜欢编程和阅读
+      `);
+    });
+
+    it('works with JSON', () => {
+      expect(queryResultsToString(queryResult, 'json')).toEqual(sane`
+        {"__time":"1970-01-01T00:00:00.000Z","name":"Jane \\"JD\\" Smith","age":34,"city":"Los Angeles","bio":"Enjoys \\"live music\\" and travel"}
+        {"__time":"1970-01-01T00:00:00.000Z","name":"John, Doe","age":29,"city":"New York","bio":"Loves coding\\nand coffee"}
+        {"__time":"1970-01-01T00:00:00.000Z","name":"Michael, O'Connor","age":41,"city":"Chicago","bio":"Expert in AI\\\\ML"}
+        {"__time":"1970-01-01T00:00:00.000Z","name":"O'Reilly, Patrick","age":45,"city":null,"bio":"\\nLoves\\ttabs"}
+        {"__time":"1970-01-01T00:00:00.000Z","name":"李四 (Li Si)","age":27,"city":"北京 (Beijing)","bio":"喜欢编程和阅读"}
+      `);
+    });
+
+    it('works with SQL', () => {
+      expect(queryResultsToString(queryResult, 'sql')).toEqual(sane`
+        SELECT
+          CAST("c1" AS TIMESTAMP) AS "__time",
+          CAST("c2" AS VARCHAR) AS "name",
+          CAST("c3" AS BIGINT) AS "age",
+          CAST("c4" AS VARCHAR) AS "city",
+          CAST("c5" AS VARCHAR) AS "bio"
+        FROM (
+          VALUES
+          ('1970-01-01T00:00:00.000Z', 'Jane "JD" Smith', 34, 'Los Angeles', 'Enjoys "live music" and travel'),
+          ('1970-01-01T00:00:00.000Z', 'John, Doe', 29, 'New York', U&'Loves coding\000aand coffee'),
+          ('1970-01-01T00:00:00.000Z', 'Michael, O''Connor', 41, 'Chicago', 'Expert in AI\ML'),
+          ('1970-01-01T00:00:00.000Z', 'O''Reilly, Patrick', 45, NULL, U&'\000aLoves\0009tabs'),
+          ('1970-01-01T00:00:00.000Z', '李四 (Li Si)', 27, '北京 (Beijing)', '喜欢编程和阅读')
+        ) AS "t" ("c1", "c2", "c3", "c4", "c5")
+      `);
+    });
+
+    it('works with Markdown', () => {
+      expect(queryResultsToString(queryResult, 'markdown').replaceAll('\t', '\\t')).toEqual(sane`
+        | __time                   | name              | age | city         | bio                            |
+        | :----------------------- | :---------------- | --: | :----------- | :----------------------------- |
+        | 1970-01-01T00:00:00.000Z | Jane "JD" Smith   |  34 | Los Angeles  | Enjoys "live music" and travel |
+        | 1970-01-01T00:00:00.000Z | John, Doe         |  29 | New York     | Loves coding<br>and coffee     |
+        | 1970-01-01T00:00:00.000Z | Michael, O'Connor |  41 | Chicago      | Expert in AI\\ML                |
+        | 1970-01-01T00:00:00.000Z | O'Reilly, Patrick |  45 |              | <br>Loves\ttabs                 |
+        | 1970-01-01T00:00:00.000Z | 李四 (Li Si)        |  27 | 北京 (Beijing) | 喜欢编程和阅读                        |
+      `);
+    });
+  });
 });
diff --git a/web-console/src/utils/download.ts b/web-console/src/utils/download.ts
index 40b0d95e8b91..af97801012c0 100644
--- a/web-console/src/utils/download.ts
+++ b/web-console/src/utils/download.ts
@@ -19,78 +19,80 @@
 import type { QueryResult } from 'druid-query-toolkit';
 import FileSaver from 'file-saver';
 import * as JSONBig from 'json-bigint-native';
+import { Align, getMarkdownTable } from 'markdown-table-ts';
 
 import { copyAndAlert, stringifyValue } from './general';
 import { queryResultToValuesQuery } from './values-query';
 
-export type Format = 'csv' | 'tsv' | 'json' | 'sql';
-
-export function downloadUrl(url: string, filename: string) {
-  // Create a link and set the URL using `createObjectURL`
-  const link = document.createElement('a');
-  link.style.display = 'none';
-  link.href = url;
-  link.download = filename;
-  document.body.appendChild(link);
-  link.click();
-
-  // To make this work on Firefox we need to wait
-  // a little while before removing it.
-  setTimeout(() => {
-    if (!link.parentNode) return;
-    link.parentNode.removeChild(link);
-  }, 0);
-}
-
-export function formatForFormat(s: null | string | number | Date, format: 'csv' | 'tsv'): string {
+export type FileFormat = 'csv' | 'tsv' | 'json' | 'sql' | 'markdown';
+export const FILE_FORMATS: FileFormat[] = ['csv', 'tsv', 'json', 'sql', 'markdown'];
+
+const FILE_FORMAT_TO_MIME_TYPE: Record<FileFormat, string> = {
+  csv: 'text/csv',
+  tsv: 'text/tab-separated-values',
+  json: 'application/json',
+  sql: 'text/plain',
+  markdown: 'text/markdown',
+};
+
+export const FILE_FORMAT_TO_LABEL: Record<FileFormat, string> = {
+  csv: 'CSV',
+  tsv: 'TSV',
+  json: 'JSON (new line delimited)',
+  sql: 'SQL (VALUES)',
+  markdown: 'Markdown table',
+};
+
+export function stringifyCsvValue(s: null | string | number | Date): string {
   if (s == null) return '';
+  const str = stringifyValue(s).replace(/\r?\n/g, ' ').replace(/"/g, '""');
 
-  // stringify and remove line break
-  const str = stringifyValue(s).replace(/(?:\r\n|\r|\n)/g, ' ');
-
-  if (format === 'csv') {
-    // csv: single quote => double quote, handle ','
-    return `"${str.replace(/"/g, '""')}"`;
-  } else {
-    // tsv: single quote => double quote, \t => ''
-    return str.replace(/\t/g, '').replace(/"/g, '""');
+  if (/["\n\t,]/.test(str)) {
+    return `"${str}"`;
   }
+
+  return str;
 }
 
-export function downloadFile(text: string, type: string, filename: string): void {
-  let blobType;
-  switch (type) {
-    case 'json':
-      blobType = 'application/json';
-      break;
-    case 'tsv':
-      blobType = 'text/tab-separated-values';
-      break;
-    default:
-      // csv
-      blobType = `text/${type}`;
-      break;
-  }
+export function stringifyTsvValue(s: null | string | number | Date): string {
+  if (s == null) return '';
+  return stringifyValue(s).replace(/\r?\n|\t/g, ' ');
+}
 
-  const blob = new Blob([text], {
-    type: blobType,
-  });
+export function stringifyMarkdownValue(s: null | string | number | Date): string {
+  if (s == null) return '';
+  return stringifyValue(s).replace(/\r?\n/g, '<br>');
+}
+
+function queryResultToDsv(
+  queryResult: QueryResult,
+  delimiter: string,
+  valueFormatter: (v: any) => string,
+): string {
+  return [
+    queryResult.header.map(column => valueFormatter(column.name)).join(delimiter),
+    ...queryResult.rows.map(row => row.map(cell => valueFormatter(cell)).join(delimiter)),
+  ].join('\n');
+}
 
-  FileSaver.saveAs(blob, filename);
+export function downloadFile(text: string, fileFormat: FileFormat, filename: string): void {
+  FileSaver.saveAs(
+    new Blob([text], {
+      type: FILE_FORMAT_TO_MIME_TYPE[fileFormat],
+    }),
+    filename,
+  );
 }
 
-function queryResultsToString(queryResult: QueryResult, format: Format): string {
+export function queryResultsToString(queryResult: QueryResult, format: FileFormat): string {
   const { header, rows } = queryResult;
 
   switch (format) {
     case 'csv':
-    case 'tsv': {
-      const separator = format === 'csv' ? ',' : '\t';
-      return [
-        header.map(column => formatForFormat(column.name, format)).join(separator),
-        ...rows.map(r => r.map(cell => formatForFormat(cell, format)).join(separator)),
-      ].join('\n');
-    }
+      return queryResultToDsv(queryResult, ',', stringifyCsvValue);
+
+    case 'tsv':
+      return queryResultToDsv(queryResult, '\t', stringifyTsvValue);
 
     case 'sql':
       return queryResultToValuesQuery(queryResult).toString();
@@ -101,6 +103,15 @@ function queryResultsToString(queryResult: QueryResult, format: Format): string
         .map(r => JSONBig.stringify(r))
         .join('\n');
 
+    case 'markdown':
+      return getMarkdownTable({
+        table: {
+          head: header.map(column => column.name),
+          body: rows.map(row => row.map(stringifyMarkdownValue)),
+        },
+        alignment: header.map(column => (column.isNumeric() ? Align.Right : Align.Left)),
+      });
+
     default:
       throw new Error(`unknown format: ${format}`);
   }
@@ -109,13 +120,16 @@ function queryResultsToString(queryResult: QueryResult, format: Format): string
 export function downloadQueryResults(
   queryResult: QueryResult,
   filename: string,
-  format: Format,
+  fileFormat: FileFormat,
 ): void {
-  const resultString: string = queryResultsToString(queryResult, format);
-  downloadFile(resultString, format, filename);
+  const resultString: string = queryResultsToString(queryResult, fileFormat);
+  downloadFile(resultString, fileFormat, filename);
 }
 
-export function copyQueryResultsToClipboard(queryResult: QueryResult, format: Format): void {
-  const resultString: string = queryResultsToString(queryResult, format);
+export function copyQueryResultsToClipboard(
+  queryResult: QueryResult,
+  fileFormat: FileFormat,
+): void {
+  const resultString: string = queryResultsToString(queryResult, fileFormat);
   copyAndAlert(resultString, 'Query results copied to clipboard');
 }
diff --git a/web-console/src/views/workbench-view/destination-pages-pane/destination-pages-pane.tsx b/web-console/src/views/workbench-view/destination-pages-pane/destination-pages-pane.tsx
index 0ffa3125985f..d3e4648e2910 100644
--- a/web-console/src/views/workbench-view/destination-pages-pane/destination-pages-pane.tsx
+++ b/web-console/src/views/workbench-view/destination-pages-pane/destination-pages-pane.tsx
@@ -24,15 +24,7 @@ import ReactTable from 'react-table';
 import type { Execution } from '../../../druid-models';
 import { SMALL_TABLE_PAGE_SIZE } from '../../../react-table';
 import { Api, UrlBaser } from '../../../singletons';
-import {
-  clamp,
-  downloadUrl,
-  formatBytes,
-  formatInteger,
-  pluralIfNeeded,
-  tickIcon,
-  wait,
-} from '../../../utils';
+import { clamp, formatBytes, formatInteger, pluralIfNeeded, tickIcon } from '../../../utils';
 
 import './destination-pages-pane.scss';
 
@@ -77,6 +69,7 @@ export const DestinationPagesPane = React.memo(function DestinationPagesPane(
   const destination = execution.destination;
   const pages = execution.destinationPages;
   if (!pages) return null;
+  const numPages = pages.length;
   const id = Api.encodePath(execution.id);
 
   const numTotalRows = destination?.numTotalRows;
@@ -85,23 +78,21 @@ export const DestinationPagesPane = React.memo(function DestinationPagesPane(
     return UrlBaser.base(
       `/druid/v2/sql/statements/${id}/results?${
         pageIndex < 0 ? '' : `page=${pageIndex}&`
-      }resultFormat=${desiredResultFormat}`,
+      }resultFormat=${desiredResultFormat}&filename=${getPageFilename(pageIndex)}`,
     );
   }
 
-  function getPageFilename(pageIndex: number, numPages: number) {
+  function getFilenamePageInfo(pageIndex: number) {
+    if (pageIndex < 0) return 'all_data';
     const numPagesString = String(numPages);
     const pageNumberString = String(pageIndex + 1).padStart(numPagesString.length, '0');
-    return `${id}_page_${pageNumberString}_of_${numPagesString}.${desiredExtension}`;
+    return `page_${pageNumberString}_of_${numPagesString}`;
   }
 
-  async function downloadAllData() {
-    if (!pages) return;
-    downloadUrl(getResultUrl(-1), `${id}_all_data.${desiredExtension}`);
-    await wait(100);
+  function getPageFilename(pageIndex: number) {
+    return `${id}_${getFilenamePageInfo(pageIndex)}.${desiredExtension}`;
   }
 
-  const numPages = pages.length;
   return (
     <div className="destination-pages-pane">
       <p>
@@ -133,14 +124,13 @@ export const DestinationPagesPane = React.memo(function DestinationPagesPane(
             rightIcon={IconNames.CARET_DOWN}
           />
         </Popover>{' '}
-        {pages.length > 1 && (
-          <Button
-            intent={Intent.PRIMARY}
-            icon={IconNames.DOWNLOAD}
-            text="Download all data (concatenated)"
-            onClick={() => void downloadAllData()}
-          />
-        )}
+        <AnchorButton
+          intent={Intent.PRIMARY}
+          icon={IconNames.DOWNLOAD}
+          text="Download all data (concatenated)"
+          href={getResultUrl(-1)}
+          download
+        />
       </p>
       <ReactTable
         data={pages}
@@ -184,7 +174,7 @@ export const DestinationPagesPane = React.memo(function DestinationPagesPane(
                 text="Download"
                 minimal
                 href={getResultUrl(value)}
-                download={getPageFilename(value, numPages)}
+                download
               />
             ),
           },
diff --git a/web-console/src/views/workbench-view/execution-summary-panel/execution-summary-panel.tsx b/web-console/src/views/workbench-view/execution-summary-panel/execution-summary-panel.tsx
index fa8bdceef018..6cb9c644468f 100644
--- a/web-console/src/views/workbench-view/execution-summary-panel/execution-summary-panel.tsx
+++ b/web-console/src/views/workbench-view/execution-summary-panel/execution-summary-panel.tsx
@@ -16,17 +16,27 @@
  * limitations under the License.
  */
 
-import { Button, ButtonGroup, Menu, MenuItem, Popover, Position } from '@blueprintjs/core';
+import {
+  Button,
+  ButtonGroup,
+  Menu,
+  MenuDivider,
+  MenuItem,
+  Popover,
+  Position,
+} from '@blueprintjs/core';
 import { IconNames } from '@blueprintjs/icons';
 import type { JSX } from 'react';
 import React, { useState } from 'react';
 
 import type { Execution } from '../../../druid-models';
-import type { Format } from '../../../utils';
+import type { FileFormat } from '../../../utils';
 import {
   copyAndAlert,
   copyQueryResultsToClipboard,
   downloadQueryResults,
+  FILE_FORMAT_TO_LABEL,
+  FILE_FORMATS,
   formatDurationHybrid,
   formatInteger,
   oneOf,
@@ -78,11 +88,11 @@ export const ExecutionSummaryPanel = React.memo(function ExecutionSummaryPanel(
 
     const warningCount = execution?.stages?.getWarningCount();
 
-    const handleDownload = (format: Format) => {
+    const handleDownload = (format: FileFormat) => {
       downloadQueryResults(queryResult, `results-${execution.id}.${format}`, format);
     };
 
-    const handleCopy = (format: Format) => {
+    const handleCopy = (format: FileFormat) => {
       copyQueryResultsToClipboard(queryResult, format);
     };
 
@@ -110,39 +120,42 @@ export const ExecutionSummaryPanel = React.memo(function ExecutionSummaryPanel(
             : `Query ID\n${execution.id}\n(click to copy)`)
         }
       />,
-      execution?.destination?.type === 'durableStorage' && execution.destinationPages ? (
-        <Button
-          key="download"
-          icon={IconNames.DOWNLOAD}
-          data-tooltip="Download data"
-          minimal
-          onClick={() => setShowDestinationPages(true)}
-        />
-      ) : (
-        <Popover
-          key="download"
-          className="download-button"
-          content={
-            <Menu>
-              <MenuItem text="Download results as...">
-                <MenuItem text="CSV" onClick={() => handleDownload('csv')} />
-                <MenuItem text="TSV" onClick={() => handleDownload('tsv')} />
-                <MenuItem text="JSON (new line delimited)" onClick={() => handleDownload('json')} />
-                <MenuItem text="SQL (VALUES)" onClick={() => handleDownload('sql')} />
-              </MenuItem>
-              <MenuItem text="Copy to clipboard as...">
-                <MenuItem text="CSV" onClick={() => handleCopy('csv')} />
-                <MenuItem text="TSV" onClick={() => handleCopy('tsv')} />
-                <MenuItem text="JSON (new line delimited)" onClick={() => handleCopy('json')} />
-                <MenuItem text="SQL (VALUES)" onClick={() => handleCopy('sql')} />
-              </MenuItem>
-            </Menu>
-          }
-          position={Position.BOTTOM_RIGHT}
-        >
-          <Button icon={IconNames.DOWNLOAD} data-tooltip="Download data in view" minimal />
-        </Popover>
-      ),
+      <Popover
+        key="download"
+        className="download-button"
+        position={Position.BOTTOM_RIGHT}
+        content={
+          <Menu>
+            {execution.destinationPages && (
+              <>
+                <MenuDivider title="Download in bulk" />
+                <MenuItem text="Show result pages" onClick={() => setShowDestinationPages(true)} />
+                <MenuDivider title="Download data in view" />
+              </>
+            )}
+            <MenuItem text="Download results as...">
+              {FILE_FORMATS.map(fileFormat => (
+                <MenuItem
+                  key={fileFormat}
+                  text={FILE_FORMAT_TO_LABEL[fileFormat]}
+                  onClick={() => handleDownload(fileFormat)}
+                />
+              ))}
+            </MenuItem>
+            <MenuItem text="Copy to clipboard as...">
+              {FILE_FORMATS.map(fileFormat => (
+                <MenuItem
+                  key={fileFormat}
+                  text={FILE_FORMAT_TO_LABEL[fileFormat]}
+                  onClick={() => handleCopy(fileFormat)}
+                />
+              ))}
+            </MenuItem>
+          </Menu>
+        }
+      >
+        <Button icon={IconNames.DOWNLOAD} data-tooltip="Download" minimal />
+      </Popover>,
     );
   }
 

From 63e6c414bd3c6bf541e91a38edc17d3fd147a107 Mon Sep 17 00:00:00 2001
From: Lucas Capistrant <capistrant@users.noreply.github.com>
Date: Fri, 28 Mar 2025 23:11:33 -0500
Subject: [PATCH 66/99] Fix flaky unit tests in SegmentBootstrapperTest and
 KinesisIndexTaskTest (#17841)

Changes:
- Fix flakiness in SegmentBootstrapperTest
- Make TestSegmentCacheManager thread safe by moving from ArrayList to CopyOnWriteArrayList
- Modify assertions to disregard list ordering since order of list modifications is not always deterministic
- Fix flaky KinesisIndexTask tests.
---
 .../kinesis/KinesisIndexTaskTest.java         | 16 +++++--
 .../coordination/SegmentBootstrapperTest.java | 42 ++++++++++++-------
 .../test/utils/TestSegmentCacheManager.java   | 16 ++++---
 3 files changed, 51 insertions(+), 23 deletions(-)

diff --git a/extensions-core/kinesis-indexing-service/src/test/java/org/apache/druid/indexing/kinesis/KinesisIndexTaskTest.java b/extensions-core/kinesis-indexing-service/src/test/java/org/apache/druid/indexing/kinesis/KinesisIndexTaskTest.java
index eb82040a8133..fe1977d9971f 100644
--- a/extensions-core/kinesis-indexing-service/src/test/java/org/apache/druid/indexing/kinesis/KinesisIndexTaskTest.java
+++ b/extensions-core/kinesis-indexing-service/src/test/java/org/apache/druid/indexing/kinesis/KinesisIndexTaskTest.java
@@ -793,7 +793,7 @@ public void testRunWithMinimumMessageTime() throws Exception
 
     final ListenableFuture<TaskStatus> future = runTask(task);
 
-    waitUntil(task, this::isTaskReading);
+    waitUntil(task, this::isTaskPublishing);
 
     // Wait for task to exit
     Assert.assertEquals(TaskState.SUCCESS, future.get().getStatusCode());
@@ -856,7 +856,7 @@ public void testRunWithMaximumMessageTime() throws Exception
 
     final ListenableFuture<TaskStatus> future = runTask(task);
 
-    waitUntil(task, this::isTaskReading);
+    waitUntil(task, this::isTaskPublishing);
 
     // Wait for task to exit
     Assert.assertEquals(TaskState.SUCCESS, future.get().getStatusCode());
@@ -915,7 +915,7 @@ public void testRunWithTransformSpec() throws Exception
     );
 
     final ListenableFuture<TaskStatus> future = runTask(task);
-    waitUntil(task, this::isTaskReading);
+    waitUntil(task, this::isTaskPublishing);
 
     // Wait for task to exit
     Assert.assertEquals(TaskState.SUCCESS, future.get().getStatusCode());
@@ -2461,6 +2461,16 @@ private boolean isTaskReading(KinesisIndexTask task)
     return task.getRunner().getStatus() == SeekableStreamIndexTaskRunner.Status.READING;
   }
 
+  /**
+   * Return true if specified task is in PUBLISHING state
+   * @param task {@link KinesisIndexTask} having its state checked
+   * @return true if task is in PUBLISHING state, otherwise false
+   */
+  private boolean isTaskPublishing(KinesisIndexTask task)
+  {
+    return task.getRunner().getStatus() == SeekableStreamIndexTaskRunner.Status.PUBLISHING;
+  }
+
   private static KinesisRecordEntity kjb(
       String timestamp,
       String dim1,
diff --git a/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperTest.java b/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperTest.java
index 461fddf7e48d..4c543faec9b4 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperTest.java
@@ -151,11 +151,12 @@ public void testStartStop() throws Exception
       Assert.assertEquals(2L, segmentManager.getDataSourceCounts().get("test_two" + i).longValue());
     }
 
-    Assert.assertEquals(ImmutableList.copyOf(segments), segmentAnnouncer.getObservedSegments());
-
     final ImmutableList<DataSegment> expectedBootstrapSegments = ImmutableList.copyOf(segments);
-    Assert.assertEquals(expectedBootstrapSegments, cacheManager.getObservedBootstrapSegments());
-    Assert.assertEquals(expectedBootstrapSegments, cacheManager.getObservedBootstrapSegmentsLoadedIntoPageCache());
+
+    assertUnsortedListsAreEqual(expectedBootstrapSegments, segmentAnnouncer.getObservedSegments());
+    assertUnsortedListsAreEqual(expectedBootstrapSegments, cacheManager.getObservedBootstrapSegments());
+    assertUnsortedListsAreEqual(expectedBootstrapSegments, cacheManager.getObservedBootstrapSegmentsLoadedIntoPageCache());
+
     Assert.assertEquals(ImmutableList.of(), cacheManager.getObservedSegments());
     Assert.assertEquals(ImmutableList.of(), cacheManager.getObservedSegmentsLoadedIntoPageCache());
 
@@ -216,11 +217,12 @@ public void testLoadCachedSegments() throws Exception
       Assert.assertEquals(2L, segmentManager.getDataSourceCounts().get("test_two" + i).longValue());
     }
 
-    Assert.assertEquals(ImmutableList.copyOf(segments), segmentAnnouncer.getObservedSegments());
-
     final ImmutableList<DataSegment> expectedBootstrapSegments = ImmutableList.copyOf(segments);
-    Assert.assertEquals(expectedBootstrapSegments, cacheManager.getObservedBootstrapSegments());
-    Assert.assertEquals(expectedBootstrapSegments, cacheManager.getObservedBootstrapSegmentsLoadedIntoPageCache());
+
+    assertUnsortedListsAreEqual(expectedBootstrapSegments, segmentAnnouncer.getObservedSegments());
+    assertUnsortedListsAreEqual(expectedBootstrapSegments, cacheManager.getObservedBootstrapSegments());
+    assertUnsortedListsAreEqual(expectedBootstrapSegments, cacheManager.getObservedBootstrapSegmentsLoadedIntoPageCache());
+
     Assert.assertEquals(ImmutableList.of(), cacheManager.getObservedSegments());
     Assert.assertEquals(ImmutableList.of(), cacheManager.getObservedSegmentsLoadedIntoPageCache());
 
@@ -275,10 +277,10 @@ public void testLoadBootstrapSegments() throws Exception
 
     final ImmutableList<DataSegment> expectedBootstrapSegments = ImmutableList.copyOf(segments);
 
-    Assert.assertEquals(expectedBootstrapSegments, segmentAnnouncer.getObservedSegments());
+    assertUnsortedListsAreEqual(expectedBootstrapSegments, segmentAnnouncer.getObservedSegments());
+    assertUnsortedListsAreEqual(expectedBootstrapSegments, cacheManager.getObservedBootstrapSegments());
+    assertUnsortedListsAreEqual(expectedBootstrapSegments, cacheManager.getObservedBootstrapSegmentsLoadedIntoPageCache());
 
-    Assert.assertEquals(expectedBootstrapSegments, cacheManager.getObservedBootstrapSegments());
-    Assert.assertEquals(expectedBootstrapSegments, cacheManager.getObservedBootstrapSegmentsLoadedIntoPageCache());
     serviceEmitter.verifyValue("segment/bootstrap/count", expectedBootstrapSegments.size());
     serviceEmitter.verifyEmitted("segment/bootstrap/time", 1);
 
@@ -405,10 +407,10 @@ public void testLoadOnlyRequiredBootstrapSegments() throws Exception
 
     final ImmutableList<DataSegment> expectedBootstrapSegments = ImmutableList.of(ds1Segment2, ds1Segment1);
 
-    Assert.assertEquals(expectedBootstrapSegments, segmentAnnouncer.getObservedSegments());
+    assertUnsortedListsAreEqual(expectedBootstrapSegments, segmentAnnouncer.getObservedSegments());
+    assertUnsortedListsAreEqual(expectedBootstrapSegments, cacheManager.getObservedBootstrapSegments());
+    assertUnsortedListsAreEqual(expectedBootstrapSegments, cacheManager.getObservedBootstrapSegmentsLoadedIntoPageCache());
 
-    Assert.assertEquals(expectedBootstrapSegments, cacheManager.getObservedBootstrapSegments());
-    Assert.assertEquals(expectedBootstrapSegments, cacheManager.getObservedBootstrapSegmentsLoadedIntoPageCache());
     serviceEmitter.verifyValue("segment/bootstrap/count", expectedBootstrapSegments.size());
     serviceEmitter.verifyEmitted("segment/bootstrap/time", 1);
 
@@ -452,4 +454,16 @@ public void testLoadBootstrapSegmentsWhenExceptionThrown() throws Exception
 
     bootstrapper.stop();
   }
+
+  /**
+   * Given two lists, assert they are equivalent and contain the same set of entries irrespecive of entry ordering
+   * @param expected The expected result list
+   * @param actual The actual result list
+   * @param <T> Object type stored in the list parameters
+   */
+  private static <T> void assertUnsortedListsAreEqual(List<T> expected, List<T> actual)
+  {
+    Assert.assertEquals(expected.size(), actual.size());
+    Assert.assertEquals(Set.copyOf(expected), Set.copyOf(actual));
+  }
 }
diff --git a/server/src/test/java/org/apache/druid/test/utils/TestSegmentCacheManager.java b/server/src/test/java/org/apache/druid/test/utils/TestSegmentCacheManager.java
index 54a7d81fc9aa..0f6020460e0f 100644
--- a/server/src/test/java/org/apache/druid/test/utils/TestSegmentCacheManager.java
+++ b/server/src/test/java/org/apache/druid/test/utils/TestSegmentCacheManager.java
@@ -30,9 +30,9 @@
 import org.apache.druid.timeline.DataSegment;
 import org.joda.time.Interval;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
+import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.atomic.AtomicInteger;
 
 /**
@@ -59,11 +59,15 @@ public TestSegmentCacheManager()
   public TestSegmentCacheManager(final Set<DataSegment> segmentsToCache)
   {
     this.cachedSegments = ImmutableList.copyOf(segmentsToCache);
-    this.observedBootstrapSegments = new ArrayList<>();
-    this.observedBootstrapSegmentsLoadedIntoPageCache = new ArrayList<>();
-    this.observedSegments = new ArrayList<>();
-    this.observedSegmentsLoadedIntoPageCache = new ArrayList<>();
-    this.observedSegmentsRemovedFromCache = new ArrayList<>();
+
+    // While inneficient, these CopyOnWriteArrayList objects greatly simplify meeting the thread
+    // safety mandate from SegmentCacheManager. For testing, this should be ok.
+    this.observedBootstrapSegments = new CopyOnWriteArrayList<>();
+    this.observedBootstrapSegmentsLoadedIntoPageCache = new CopyOnWriteArrayList<>();
+    this.observedSegments = new CopyOnWriteArrayList<>();
+    this.observedSegmentsLoadedIntoPageCache = new CopyOnWriteArrayList<>();
+    this.observedSegmentsRemovedFromCache = new CopyOnWriteArrayList<>();
+
     this.observedShutdownBootstrapCount = new AtomicInteger(0);
   }
 

From c580b2a4614f4f4cebcc80a29587b917c4b670e3 Mon Sep 17 00:00:00 2001
From: Vadim Ogievetsky <vadim@ogievetsky.com>
Date: Sat, 29 Mar 2025 07:33:02 -0700
Subject: [PATCH 67/99] Web console: responding to user feedback about the
 explore view and fixing bugs (#17844)

* better debounce

* better cumpose filter

* hook up preview filters

* better stack handling

* fix some props

* refactor stack to facet

* fix hover part 1

* line hover part 2

* start adding moduleWhere

* info popover

* add filter icon

* toggle button

* module filter bar
---
 web-console/src/utils/general.tsx             |  17 +++
 .../src/utils/query-manager/query-manager.ts  |  13 +-
 .../column-picker-menu/column-picker-menu.tsx |  37 +++--
 .../contains-filter-control.tsx               |   6 +-
 .../filter-pane/filter-menu/filter-menu.tsx   |  28 +++-
 .../regexp-filter-control.tsx                 |  11 +-
 .../time-interval-filter-control.tsx          |  50 +++++--
 .../values-filter-control.tsx                 |  59 +++++---
 .../components/filter-pane/filter-pane.tsx    |   8 +-
 .../views/explore-view/components/index.ts    |   2 +-
 .../iso-date-input.tsx}                       |  40 ++++--
 .../components/module-pane/module-pane.scss   |  48 +++++--
 .../components/module-pane/module-pane.tsx    |  96 ++++++++-----
 .../components/preview-pane/preview-pane.scss |   6 +
 .../components/preview-pane/preview-pane.tsx  |  19 ++-
 .../column-dialog/column-dialog.tsx           |  26 ++--
 .../measure-dialog/measure-dialog.tsx         |  26 ++--
 .../resource-pane/resource-pane.tsx           |   6 +-
 .../src/views/explore-view/explore-view.scss  |   1 +
 .../src/views/explore-view/explore-view.tsx   |  22 +--
 .../views/explore-view/models/module-state.ts |  27 ++--
 .../views/explore-view/models/parameter.ts    |   7 +-
 .../views/explore-view/models/query-source.ts |   2 +-
 .../module-repository/module-repository.ts    |   1 +
 .../bar-chart-module/bar-chart-module.tsx     |  25 +++-
 .../grouping-table-module.tsx                 |  15 +-
 .../multi-axis-chart-module.tsx               |  15 +-
 .../pie-chart-module/pie-chart-module.tsx     |  30 ++--
 .../record-table-module.tsx                   |  15 +-
 .../continuous-chart-render.scss              |  20 +--
 .../continuous-chart-render.tsx               | 134 ++++++++++--------
 .../time-chart-module/time-chart-module.tsx   | 118 +++++++++------
 32 files changed, 631 insertions(+), 299 deletions(-)
 rename web-console/src/views/explore-view/components/{utc-date-input/utc-date-input.tsx => iso-date-input/iso-date-input.tsx} (62%)

diff --git a/web-console/src/utils/general.tsx b/web-console/src/utils/general.tsx
index 8af818664fd1..d204c7a89e07 100644
--- a/web-console/src/utils/general.tsx
+++ b/web-console/src/utils/general.tsx
@@ -458,6 +458,23 @@ export function findMap<T, Q>(
   return filterMap(xs, f)[0];
 }
 
+export function minBy<T>(xs: T[], f: (item: T, index: number) => number): T | undefined {
+  if (!xs.length) return undefined;
+
+  let minItem = xs[0];
+  let minValue = f(xs[0], 0);
+
+  for (let i = 1; i < xs.length; i++) {
+    const currentValue = f(xs[i], i);
+    if (currentValue < minValue) {
+      minValue = currentValue;
+      minItem = xs[i];
+    }
+  }
+
+  return minItem;
+}
+
 export function changeByIndex<T>(
   xs: readonly T[],
   i: number,
diff --git a/web-console/src/utils/query-manager/query-manager.ts b/web-console/src/utils/query-manager/query-manager.ts
index 0b7fcf5680ed..b7cbf3ab1c5d 100644
--- a/web-console/src/utils/query-manager/query-manager.ts
+++ b/web-console/src/utils/query-manager/query-manager.ts
@@ -39,6 +39,7 @@ export interface QueryManagerOptions<Q, R, I = never, E extends Error = Error> {
     cancelToken: CancelToken,
   ) => Promise<R | IntermediateQueryState<I> | ResultWithAuxiliaryWork<R>>;
   onStateChange?: (queryResolve: QueryState<R, E, I>) => void;
+  debounceInit?: number;
   debounceIdle?: number;
   debounceLoading?: number;
   backgroundStatusCheckInitDelay?: number;
@@ -78,6 +79,7 @@ export class QueryManager<Q, R, I = never, E extends Error = Error> {
   private state: QueryState<R, E, I>;
   private currentQueryId = 0;
 
+  private readonly runWhenInit: () => void | Promise<void>;
   private readonly runWhenIdle: () => void | Promise<void>;
   private readonly runWhenLoading: () => void | Promise<void>;
 
@@ -88,6 +90,11 @@ export class QueryManager<Q, R, I = never, E extends Error = Error> {
     this.backgroundStatusCheckInitDelay = options.backgroundStatusCheckInitDelay || 500;
     this.backgroundStatusCheckDelay = options.backgroundStatusCheckDelay || 1000;
     this.swallowBackgroundError = options.swallowBackgroundError;
+    if (options.debounceInit !== 0) {
+      this.runWhenInit = debounce(this.run, options.debounceInit || 50);
+    } else {
+      this.runWhenInit = this.run;
+    }
     if (options.debounceIdle !== 0) {
       this.runWhenIdle = debounce(this.run, options.debounceIdle || 100);
     } else {
@@ -257,7 +264,11 @@ export class QueryManager<Q, R, I = never, E extends Error = Error> {
         }),
       );
 
-      void this.runWhenIdle();
+      if (this.lastQuery) {
+        void this.runWhenIdle();
+      } else {
+        void this.runWhenInit();
+      }
     }
   }
 
diff --git a/web-console/src/views/explore-view/components/column-picker-menu/column-picker-menu.tsx b/web-console/src/views/explore-view/components/column-picker-menu/column-picker-menu.tsx
index 7634cbae4ccd..597df5c4d817 100644
--- a/web-console/src/views/explore-view/components/column-picker-menu/column-picker-menu.tsx
+++ b/web-console/src/views/explore-view/components/column-picker-menu/column-picker-menu.tsx
@@ -17,13 +17,14 @@
  */
 
 import type { IconName } from '@blueprintjs/core';
-import { Icon, InputGroup, Menu, MenuItem } from '@blueprintjs/core';
+import { ContextMenu, Icon, InputGroup, Menu, MenuItem } from '@blueprintjs/core';
 import { IconNames } from '@blueprintjs/icons';
 import classNames from 'classnames';
 import type { Column } from 'druid-query-toolkit';
+import { C } from 'druid-query-toolkit';
 import { useState } from 'react';
 
-import { caseInsensitiveContains, columnToIcon, filterMap } from '../../../../utils';
+import { caseInsensitiveContains, columnToIcon, copyAndAlert, filterMap } from '../../../../utils';
 
 import './column-picker-menu.scss';
 
@@ -66,17 +67,33 @@ export const ColumnPickerMenu = function ColumnPickerMenu(props: ColumnPickerMen
           />
         )}
         {filterMap(columns, (c, i) => {
-          if (!caseInsensitiveContains(c.name, columnSearch)) return;
+          const columnName = c.name;
+          if (!caseInsensitiveContains(columnName, columnSearch)) return;
           const iconName = rightIconForColumn?.(c);
           return (
-            <MenuItem
+            <ContextMenu
               key={i}
-              icon={columnToIcon(c) || IconNames.BLANK}
-              text={c.name}
-              labelElement={iconName && <Icon icon={iconName} />}
-              onClick={() => onSelectColumn(c)}
-              shouldDismissPopover={shouldDismissPopover}
-            />
+              content={
+                <Menu>
+                  <MenuItem
+                    text="Copy"
+                    onClick={() => copyAndAlert(String(columnName), `Copied to clipboard`)}
+                  />
+                  <MenuItem
+                    text="Copy as SQL column"
+                    onClick={() => copyAndAlert(String(C(columnName)), `Copied to clipboard`)}
+                  />
+                </Menu>
+              }
+            >
+              <MenuItem
+                icon={columnToIcon(c) || IconNames.BLANK}
+                text={columnName}
+                labelElement={iconName && <Icon icon={iconName} />}
+                onClick={() => onSelectColumn(c)}
+                shouldDismissPopover={shouldDismissPopover}
+              />
+            </ContextMenu>
           );
         })}
       </Menu>
diff --git a/web-console/src/views/explore-view/components/filter-pane/filter-menu/contains-filter-control/contains-filter-control.tsx b/web-console/src/views/explore-view/components/filter-pane/filter-menu/contains-filter-control/contains-filter-control.tsx
index b3b6892bb4bd..15b9a75cadc4 100644
--- a/web-console/src/views/explore-view/components/filter-pane/filter-menu/contains-filter-control/contains-filter-control.tsx
+++ b/web-console/src/views/explore-view/components/filter-pane/filter-menu/contains-filter-control/contains-filter-control.tsx
@@ -30,6 +30,7 @@ import './contains-filter-control.scss';
 
 export interface ContainsFilterControlProps {
   querySource: QuerySource;
+  extraFilter: SqlExpression;
   filter: SqlExpression;
   filterPattern: ContainsFilterPattern;
   setFilterPattern(filterPattern: ContainsFilterPattern): void;
@@ -39,7 +40,7 @@ export interface ContainsFilterControlProps {
 export const ContainsFilterControl = React.memo(function ContainsFilterControl(
   props: ContainsFilterControlProps,
 ) {
-  const { querySource, filter, filterPattern, setFilterPattern, runSqlQuery } = props;
+  const { querySource, extraFilter, filter, filterPattern, setFilterPattern, runSqlQuery } = props;
   const { column, negated, contains } = filterPattern;
 
   const previewQuery = useMemo(
@@ -47,6 +48,7 @@ export const ContainsFilterControl = React.memo(function ContainsFilterControl(
       querySource
         .getInitQuery(
           SqlExpression.and(
+            extraFilter,
             filter,
             contains ? filterPatternToExpression(filterPattern) : undefined,
           ),
@@ -56,7 +58,7 @@ export const ContainsFilterControl = React.memo(function ContainsFilterControl(
         .changeLimitValue(101)
         .toString(),
     // eslint-disable-next-line react-hooks/exhaustive-deps -- exclude 'makePattern' from deps
-    [querySource.query, filter, column, contains, negated],
+    [querySource.query, extraFilter, filter, column, contains, negated],
   );
 
   const [previewState] = useQueryManager<string, string[]>({
diff --git a/web-console/src/views/explore-view/components/filter-pane/filter-menu/filter-menu.tsx b/web-console/src/views/explore-view/components/filter-pane/filter-menu/filter-menu.tsx
index b5f5ee2fc9b7..39cff40d2a97 100644
--- a/web-console/src/views/explore-view/components/filter-pane/filter-menu/filter-menu.tsx
+++ b/web-console/src/views/explore-view/components/filter-pane/filter-menu/filter-menu.tsx
@@ -108,6 +108,7 @@ type FilterMenuTab = 'compose' | 'sql';
 
 export interface FilterMenuProps {
   querySource: QuerySource;
+  extraFilter: SqlExpression;
   filter: SqlExpression;
   initPattern?: FilterPattern;
   onPatternChange(newPattern: FilterPattern): void;
@@ -121,6 +122,7 @@ export interface FilterMenuProps {
 export const FilterMenu = React.memo(function FilterMenu(props: FilterMenuProps) {
   const {
     querySource,
+    extraFilter,
     filter,
     initPattern,
     onPatternChange,
@@ -136,8 +138,18 @@ export const FilterMenu = React.memo(function FilterMenu(props: FilterMenuProps)
     initPattern?.type === 'custom' ? filterPatternToExpression(initPattern).toString() : '',
   );
   const [pattern, setPattern] = useState<FilterPattern | undefined>(initPattern);
+  const [issue, setIssue] = useState<string | undefined>();
   const { columns } = querySource;
 
+  function setFilterPatternOrIssue(pattern: FilterPattern | undefined, issue: string | undefined) {
+    if (pattern) {
+      setPattern(pattern);
+      setIssue(undefined);
+    } else {
+      setIssue(issue || 'Issue');
+    }
+  }
+
   function onAcceptPattern(pattern: FilterPattern) {
     onPatternChange(pattern);
     onClose();
@@ -151,6 +163,7 @@ export const FilterMenu = React.memo(function FilterMenu(props: FilterMenuProps)
       cont = (
         <ValuesFilterControl
           querySource={querySource}
+          extraFilter={extraFilter}
           filter={filter}
           filterPattern={pattern}
           setFilterPattern={setPattern}
@@ -163,6 +176,7 @@ export const FilterMenu = React.memo(function FilterMenu(props: FilterMenuProps)
       cont = (
         <ContainsFilterControl
           querySource={querySource}
+          extraFilter={extraFilter}
           filter={filter}
           filterPattern={pattern}
           setFilterPattern={setPattern}
@@ -175,6 +189,7 @@ export const FilterMenu = React.memo(function FilterMenu(props: FilterMenuProps)
       cont = (
         <RegexpFilterControl
           querySource={querySource}
+          extraFilter={extraFilter}
           filter={filter}
           filterPattern={pattern}
           setFilterPattern={setPattern}
@@ -198,7 +213,8 @@ export const FilterMenu = React.memo(function FilterMenu(props: FilterMenuProps)
         <TimeIntervalFilterControl
           querySource={querySource}
           filterPattern={pattern}
-          setFilterPattern={setPattern}
+          setFilterPatternOrIssue={setFilterPatternOrIssue}
+          onIssue={setIssue}
         />
       );
       break;
@@ -281,6 +297,7 @@ export const FilterMenu = React.memo(function FilterMenu(props: FilterMenuProps)
             active={tab === 'sql'}
             onClick={() => {
               setFormula(pattern ? filterPatternToExpression(pattern).toString() : '');
+              setIssue(undefined);
               setTab('sql');
             }}
           />
@@ -416,8 +433,17 @@ export const FilterMenu = React.memo(function FilterMenu(props: FilterMenuProps)
             intent={Intent.PRIMARY}
             text="Apply"
             disabled={tab === 'sql' && formula === ''}
+            data-tooltip={issue ? `Issue: ${issue}` : undefined}
             onClick={() => {
               if (tab === 'compose') {
+                if (issue) {
+                  AppToaster.show({
+                    message: issue,
+                    intent: Intent.DANGER,
+                  });
+                  return;
+                }
+
                 if (pattern) {
                   onAcceptPattern(pattern);
                 }
diff --git a/web-console/src/views/explore-view/components/filter-pane/filter-menu/regexp-filter-control/regexp-filter-control.tsx b/web-console/src/views/explore-view/components/filter-pane/filter-menu/regexp-filter-control/regexp-filter-control.tsx
index 23d67ff2ec5a..fa0820667e2d 100644
--- a/web-console/src/views/explore-view/components/filter-pane/filter-menu/regexp-filter-control/regexp-filter-control.tsx
+++ b/web-console/src/views/explore-view/components/filter-pane/filter-menu/regexp-filter-control/regexp-filter-control.tsx
@@ -39,6 +39,7 @@ function regexpIssue(possibleRegexp: string): string | undefined {
 
 export interface RegexpFilterControlProps {
   querySource: QuerySource;
+  extraFilter: SqlExpression;
   filter: SqlExpression;
   filterPattern: RegexpFilterPattern;
   setFilterPattern(filterPattern: RegexpFilterPattern): void;
@@ -48,21 +49,25 @@ export interface RegexpFilterControlProps {
 export const RegexpFilterControl = React.memo(function RegexpFilterControl(
   props: RegexpFilterControlProps,
 ) {
-  const { querySource, filter, filterPattern, setFilterPattern, runSqlQuery } = props;
+  const { querySource, extraFilter, filter, filterPattern, setFilterPattern, runSqlQuery } = props;
   const { column, negated, regexp } = filterPattern;
 
   const previewQuery = useMemo(
     () =>
       querySource
         .getInitQuery(
-          SqlExpression.and(filter, regexp ? filterPatternToExpression(filterPattern) : undefined),
+          SqlExpression.and(
+            extraFilter,
+            filter,
+            regexp ? filterPatternToExpression(filterPattern) : undefined,
+          ),
         )
         .addSelect(F.cast(C(column), 'VARCHAR').as('c'), { addToGroupBy: 'end' })
         .changeOrderByExpression(F.count().toOrderByExpression('DESC'))
         .changeLimitValue(101)
         .toString(),
     // eslint-disable-next-line react-hooks/exhaustive-deps -- exclude 'makePattern' from deps
-    [querySource.query, filter, column, regexp, negated],
+    [querySource.query, extraFilter, filter, column, regexp, negated],
   );
 
   const [previewState] = useQueryManager<string, string[]>({
diff --git a/web-console/src/views/explore-view/components/filter-pane/filter-menu/time-interval-filter-control/time-interval-filter-control.tsx b/web-console/src/views/explore-view/components/filter-pane/filter-menu/time-interval-filter-control/time-interval-filter-control.tsx
index 9200ee9e07e1..36bee8702838 100644
--- a/web-console/src/views/explore-view/components/filter-pane/filter-menu/time-interval-filter-control/time-interval-filter-control.tsx
+++ b/web-console/src/views/explore-view/components/filter-pane/filter-menu/time-interval-filter-control/time-interval-filter-control.tsx
@@ -18,35 +18,69 @@
 
 import { FormGroup } from '@blueprintjs/core';
 import type { TimeIntervalFilterPattern } from 'druid-query-toolkit';
-import React from 'react';
+import React, { useState } from 'react';
 
 import type { QuerySource } from '../../../../models';
-import { UtcDateInput } from '../../../utc-date-input/utc-date-input';
+import { IsoDateInput } from '../../../iso-date-input/iso-date-input';
 
 import './time-interval-filter-control.scss';
 
+function isSwappedFilterPattern(pattern: TimeIntervalFilterPattern) {
+  return pattern.end <= pattern.start;
+}
+
 export interface TimeIntervalFilterControlProps {
   querySource: QuerySource;
   filterPattern: TimeIntervalFilterPattern;
-  setFilterPattern(filterPattern: TimeIntervalFilterPattern): void;
+  setFilterPatternOrIssue(
+    filterPattern: TimeIntervalFilterPattern | undefined,
+    issue: string | undefined,
+  ): void;
+  onIssue(issue: string): void;
 }
 
 export const TimeIntervalFilterControl = React.memo(function TimeIntervalFilterControl(
   props: TimeIntervalFilterControlProps,
 ) {
-  const { filterPattern, setFilterPattern } = props;
-  const { start, end } = filterPattern;
+  const { filterPattern, setFilterPatternOrIssue, onIssue } = props;
+  const [swappedFilterPattern, setSwappedFilterPattern] = useState<
+    TimeIntervalFilterPattern | undefined
+  >();
+  const { start, end } = swappedFilterPattern || filterPattern;
 
   return (
     <div className="time-interval-filter-control">
       <FormGroup label="Start">
-        <UtcDateInput
+        <IsoDateInput
           date={start}
-          onChange={start => setFilterPattern({ ...filterPattern, start })}
+          onChange={start => {
+            const newPattern = { ...filterPattern, start };
+            if (isSwappedFilterPattern(newPattern)) {
+              setSwappedFilterPattern(newPattern);
+              setFilterPatternOrIssue(undefined, 'Start date must be before end date');
+            } else {
+              setSwappedFilterPattern(undefined);
+              setFilterPatternOrIssue(newPattern, undefined);
+            }
+          }}
+          onIssue={() => onIssue('Bad start date')}
         />
       </FormGroup>
       <FormGroup label="End">
-        <UtcDateInput date={end} onChange={end => setFilterPattern({ ...filterPattern, end })} />
+        <IsoDateInput
+          date={end}
+          onChange={end => {
+            const newPattern = { ...filterPattern, end };
+            if (isSwappedFilterPattern(newPattern)) {
+              setSwappedFilterPattern(newPattern);
+              setFilterPatternOrIssue(undefined, 'End date must be after start date');
+            } else {
+              setSwappedFilterPattern(undefined);
+              setFilterPatternOrIssue(newPattern, undefined);
+            }
+          }}
+          onIssue={() => onIssue('Bad end date')}
+        />
       </FormGroup>
     </div>
   );
diff --git a/web-console/src/views/explore-view/components/filter-pane/filter-menu/values-filter-control/values-filter-control.tsx b/web-console/src/views/explore-view/components/filter-pane/filter-menu/values-filter-control/values-filter-control.tsx
index f14851f081fb..cf4701fe4563 100644
--- a/web-console/src/views/explore-view/components/filter-pane/filter-menu/values-filter-control/values-filter-control.tsx
+++ b/web-console/src/views/explore-view/components/filter-pane/filter-menu/values-filter-control/values-filter-control.tsx
@@ -16,16 +16,16 @@
  * limitations under the License.
  */
 
-import { FormGroup, Menu, MenuItem } from '@blueprintjs/core';
+import { ContextMenu, FormGroup, Menu, MenuItem } from '@blueprintjs/core';
 import { IconNames } from '@blueprintjs/icons';
 import type { CancelToken } from 'axios';
 import type { QueryResult, SqlQuery, ValuesFilterPattern } from 'druid-query-toolkit';
-import { C, F, SqlExpression } from 'druid-query-toolkit';
+import { C, F, L, SqlExpression } from 'druid-query-toolkit';
 import React, { useMemo, useState } from 'react';
 
 import { ClearableInput } from '../../../../../../components';
 import { useQueryManager } from '../../../../../../hooks';
-import { caseInsensitiveContains, filterMap, toggle } from '../../../../../../utils';
+import { caseInsensitiveContains, copyAndAlert, filterMap, toggle } from '../../../../../../utils';
 import type { QuerySource } from '../../../../models';
 import { ColumnValue } from '../../../column-value/column-value';
 
@@ -33,6 +33,7 @@ import './values-filter-control.scss';
 
 export interface ValuesFilterControlProps {
   querySource: QuerySource;
+  extraFilter: SqlExpression;
   filter: SqlExpression;
   filterPattern: ValuesFilterPattern;
   setFilterPattern(filterPattern: ValuesFilterPattern): void;
@@ -42,7 +43,7 @@ export interface ValuesFilterControlProps {
 export const ValuesFilterControl = React.memo(function ValuesFilterControl(
   props: ValuesFilterControlProps,
 ) {
-  const { querySource, filter, filterPattern, setFilterPattern, runSqlQuery } = props;
+  const { querySource, extraFilter, filter, filterPattern, setFilterPattern, runSqlQuery } = props;
   const { column, negated, values: selectedValues } = filterPattern;
   const [initValues] = useState(selectedValues);
   const [searchString, setSearchString] = useState('');
@@ -52,6 +53,7 @@ export const ValuesFilterControl = React.memo(function ValuesFilterControl(
       querySource
         .getInitQuery(
           SqlExpression.and(
+            extraFilter,
             filter,
             searchString ? F('ICONTAINS_STRING', C(column), searchString) : undefined,
           ),
@@ -61,7 +63,7 @@ export const ValuesFilterControl = React.memo(function ValuesFilterControl(
         .changeLimitValue(101)
         .toString(),
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [querySource.query, filter, column, searchString],
+    [querySource.query, extraFilter, filter, column, searchString],
   );
 
   const [valuesState] = useQueryManager<string, any[]>({
@@ -90,24 +92,39 @@ export const ValuesFilterControl = React.memo(function ValuesFilterControl(
         {filterMap(valuesToShow, (v, i) => {
           if (!caseInsensitiveContains(v, searchString)) return;
           return (
-            <MenuItem
+            <ContextMenu
               key={i}
-              icon={
-                selectedValues.includes(v)
-                  ? negated
-                    ? IconNames.DELETE
-                    : IconNames.TICK_CIRCLE
-                  : IconNames.CIRCLE
+              content={
+                <Menu>
+                  <MenuItem
+                    text="Copy"
+                    onClick={() => copyAndAlert(String(v), `Copied to clipboard`)}
+                  />
+                  <MenuItem
+                    text="Copy as SQL value"
+                    onClick={() => copyAndAlert(String(L(v)), `Copied to clipboard`)}
+                  />
+                </Menu>
               }
-              text={<ColumnValue value={v} />}
-              shouldDismissPopover={false}
-              onClick={e => {
-                setFilterPattern({
-                  ...filterPattern,
-                  values: e.altKey ? [v] : toggle(selectedValues, v),
-                });
-              }}
-            />
+            >
+              <MenuItem
+                icon={
+                  selectedValues.includes(v)
+                    ? negated
+                      ? IconNames.DELETE
+                      : IconNames.TICK_CIRCLE
+                    : IconNames.CIRCLE
+                }
+                text={<ColumnValue value={v} />}
+                shouldDismissPopover={false}
+                onClick={e => {
+                  setFilterPattern({
+                    ...filterPattern,
+                    values: e.altKey ? [v] : toggle(selectedValues, v),
+                  });
+                }}
+              />
+            </ContextMenu>
           );
         })}
         {valuesState.loading && <MenuItem icon={IconNames.BLANK} text="Loading..." disabled />}
diff --git a/web-console/src/views/explore-view/components/filter-pane/filter-pane.tsx b/web-console/src/views/explore-view/components/filter-pane/filter-pane.tsx
index cab39295b9fe..fa62e0d65cde 100644
--- a/web-console/src/views/explore-view/components/filter-pane/filter-pane.tsx
+++ b/web-console/src/views/explore-view/components/filter-pane/filter-pane.tsx
@@ -48,6 +48,7 @@ import './filter-pane.scss';
 
 export interface FilterPaneProps {
   querySource: QuerySource | undefined;
+  extraFilter: SqlExpression;
   timezone: Timezone;
   filter: SqlExpression;
   onFilterChange(filter: SqlExpression): void;
@@ -59,6 +60,7 @@ export interface FilterPaneProps {
 export const FilterPane = forwardRef(function FilterPane(props: FilterPaneProps, ref) {
   const {
     querySource,
+    extraFilter,
     timezone,
     filter,
     onFilterChange,
@@ -139,6 +141,7 @@ export const FilterPane = forwardRef(function FilterPane(props: FilterPaneProps,
                 content={
                   <FilterMenu
                     querySource={querySource}
+                    extraFilter={extraFilter}
                     filter={filterPatternsToExpression(without(patterns, pattern))}
                     initPattern={pattern}
                     onPatternChange={newPattern => {
@@ -201,6 +204,7 @@ export const FilterPane = forwardRef(function FilterPane(props: FilterPaneProps,
           content={
             <FilterMenu
               querySource={querySource}
+              extraFilter={extraFilter}
               filter={filter}
               initPattern={menuNew?.column ? initPatternForColumn(menuNew?.column) : undefined}
               onPatternChange={newPattern => {
@@ -220,7 +224,7 @@ export const FilterPane = forwardRef(function FilterPane(props: FilterPaneProps,
             text={patterns.length ? undefined : 'Add filter'}
             onClick={() => setMenuNew({})}
             minimal
-            data-tooltip="Add filter"
+            data-tooltip={patterns.length ? 'Add filter' : undefined}
           />
         </Popover>
       ) : (
@@ -229,7 +233,7 @@ export const FilterPane = forwardRef(function FilterPane(props: FilterPaneProps,
           text={patterns.length ? undefined : 'Add filter'}
           disabled
           minimal
-          data-tooltip="Add filter"
+          data-tooltip="No query source, unable to query"
         />
       )}
     </DroppableContainer>
diff --git a/web-console/src/views/explore-view/components/index.ts b/web-console/src/views/explore-view/components/index.ts
index 085bbff3c3e0..58a8fb6fa72e 100644
--- a/web-console/src/views/explore-view/components/index.ts
+++ b/web-console/src/views/explore-view/components/index.ts
@@ -21,6 +21,7 @@ export * from './droppable-container/droppable-container';
 export * from './filter-pane/filter-pane';
 export * from './generic-output-table/generic-output-table';
 export * from './helper-table/helper-table';
+export * from './iso-date-input/iso-date-input';
 export * from './issue/issue';
 export * from './module-pane/module-pane';
 export * from './module-picker/module-picker';
@@ -28,4 +29,3 @@ export * from './resource-pane/resource-pane';
 export * from './source-pane/source-pane';
 export * from './source-query-pane/source-query-pane';
 export * from './sql-input/sql-input';
-export * from './utc-date-input/utc-date-input';
diff --git a/web-console/src/views/explore-view/components/utc-date-input/utc-date-input.tsx b/web-console/src/views/explore-view/components/iso-date-input/iso-date-input.tsx
similarity index 62%
rename from web-console/src/views/explore-view/components/utc-date-input/utc-date-input.tsx
rename to web-console/src/views/explore-view/components/iso-date-input/iso-date-input.tsx
index b1de4ce7c13d..b145e31a2211 100644
--- a/web-console/src/views/explore-view/components/utc-date-input/utc-date-input.tsx
+++ b/web-console/src/views/explore-view/components/iso-date-input/iso-date-input.tsx
@@ -16,10 +16,10 @@
  * limitations under the License.
  */
 
-import { InputGroup } from '@blueprintjs/core';
+import { InputGroup, Intent } from '@blueprintjs/core';
 import { useState } from 'react';
 
-function utcParseDate(dateString: string): Date | undefined {
+function isoParseDate(dateString: string): Date | undefined {
   const dateParts = dateString.split(/[-T:. ]/g);
 
   // Extract the individual date and time components
@@ -44,7 +44,7 @@ function utcParseDate(dateString: string): Date | undefined {
   const millisecond = parseInt(dateParts[6], 10);
   if (millisecond >= 1000) return;
 
-  const value = Date.UTC(year, month - 1, day, hour, minute, second); // Month is zero-based
+  const value = Date.UTC(year, month - 1, day, hour, minute, second, millisecond); // Month is zero-based
   if (isNaN(value)) return;
 
   return new Date(value);
@@ -61,26 +61,42 @@ function formatDate(date: Date): string {
 export interface UtcDateInputProps {
   date: Date;
   onChange(newDate: Date): void;
+  onIssue(): void;
 }
 
-export function UtcDateInput(props: UtcDateInputProps) {
-  const { date, onChange } = props;
-  const [dateString, setDateString] = useState<string | undefined>();
+export function IsoDateInput(props: UtcDateInputProps) {
+  const { date, onChange, onIssue } = props;
+  const [invalidDateString, setInvalidDateString] = useState<string | undefined>();
+  const [customDateString, setCustomDateString] = useState<string | undefined>();
+  const [focused, setFocused] = useState<boolean>(false);
 
   return (
     <InputGroup
+      className="iso-date-input"
       placeholder="yyyy-MM-dd HH:mm:ss"
-      value={dateString ?? formatDate(date)}
+      intent={!focused && invalidDateString ? Intent.DANGER : undefined}
+      value={
+        invalidDateString ??
+        (customDateString && isoParseDate(customDateString)?.valueOf() === date.valueOf()
+          ? customDateString
+          : undefined) ??
+        formatDate(date)
+      }
       onChange={e => {
-        const v = normalizeDateString(e.target.value);
-        const parsedDate = utcParseDate(v);
-        if (parsedDate && formatDate(parsedDate) === v) {
+        const normalizedDateString = normalizeDateString(e.target.value);
+        const parsedDate = isoParseDate(normalizedDateString);
+        if (parsedDate) {
           onChange(parsedDate);
-          setDateString(undefined);
+          setInvalidDateString(undefined);
+          setCustomDateString(normalizedDateString);
         } else {
-          setDateString(v);
+          onIssue();
+          setInvalidDateString(normalizedDateString);
+          setCustomDateString(undefined);
         }
       }}
+      onFocus={() => setFocused(true)}
+      onBlur={() => setFocused(false)}
     />
   );
 }
diff --git a/web-console/src/views/explore-view/components/module-pane/module-pane.scss b/web-console/src/views/explore-view/components/module-pane/module-pane.scss
index e74e3fe4bae3..0fa698cfc9b2 100644
--- a/web-console/src/views/explore-view/components/module-pane/module-pane.scss
+++ b/web-console/src/views/explore-view/components/module-pane/module-pane.scss
@@ -18,47 +18,71 @@
 
 @import '../../../../variables';
 
-$tob-bar-height: 34px;
+$filter-bar-height: 34px;
+$control-bar-height: 34px;
 $control-pane-width: 240px;
+$small-border: 1px;
 
 .module-pane {
   position: relative;
   @include card-like;
   overflow: hidden;
 
-  .module-top-bar {
+  .filter-pane {
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 90px;
+    height: $filter-bar-height;
+    border-bottom: $small-border solid $dark-gray2;
+    padding: 2px 0;
+  }
+
+  .module-control-bar {
     position: absolute;
     top: 0;
     left: 0;
     width: 100%;
-    height: $tob-bar-height;
-    border-bottom: 1px solid $dark-gray2;
+    height: $control-bar-height;
+    border-bottom: $small-border solid $dark-gray2;
     padding: 2px;
     display: flex;
-
-    .bar-expander {
-      flex: 1;
-    }
   }
 
   .control-pane-container {
     position: absolute;
-    top: $tob-bar-height + 1;
+    top: $control-bar-height + 1;
     bottom: 0;
     width: $control-pane-width;
     right: 0;
-    border-left: 1px solid $dark-gray2;
+    border-left: $small-border solid $dark-gray2;
     padding: 8px;
     overflow: auto;
   }
 
   &.show-controls .module-inner-container {
-    right: $control-pane-width + 1;
+    right: $control-pane-width + $small-border;
+  }
+
+  &.show-filter {
+    .module-control-bar {
+      top: $filter-bar-height + $small-border;
+    }
+
+    .module-inner-container {
+      top: $filter-bar-height + $small-border + $control-bar-height + $small-border;
+    }
+  }
+
+  .corner-buttons {
+    position: absolute;
+    top: 2px;
+    right: 2px;
   }
 
   .module-inner-container {
     position: absolute;
-    top: $tob-bar-height + 1;
+    top: $control-bar-height + $small-border;
     bottom: 0;
     left: 0;
     right: 0;
diff --git a/web-console/src/views/explore-view/components/module-pane/module-pane.tsx b/web-console/src/views/explore-view/components/module-pane/module-pane.tsx
index b06e7b1c3465..96ed6e8fe90c 100644
--- a/web-console/src/views/explore-view/components/module-pane/module-pane.tsx
+++ b/web-console/src/views/explore-view/components/module-pane/module-pane.tsx
@@ -30,6 +30,7 @@ import { IconNames } from '@blueprintjs/icons';
 import type { Timezone } from 'chronoshift';
 import classNames from 'classnames';
 import type { Column, QueryResult, SqlExpression, SqlQuery } from 'druid-query-toolkit';
+import { SqlLiteral } from 'druid-query-toolkit';
 import React, { useState } from 'react';
 
 import { useMemoWithPrevious } from '../../../../hooks';
@@ -53,6 +54,7 @@ import { ModuleRepository } from '../../module-repository/module-repository';
 import { adjustTransferValue, normalizeType } from '../../utils';
 import { ControlPane } from '../control-pane/control-pane';
 import { DroppableContainer } from '../droppable-container/droppable-container';
+import { FilterPane } from '../filter-pane/filter-pane';
 import { Issue } from '../issue/issue';
 import { ModulePicker } from '../module-picker/module-picker';
 
@@ -115,7 +117,7 @@ export const ModulePane = function ModulePane(props: ModulePaneProps) {
     onAddToSourceQueryAsColumn,
     onAddToSourceQueryAsMeasure,
   } = props;
-  const { moduleId, parameterValues, showControls } = moduleState;
+  const { moduleId, moduleWhere, parameterValues, showModuleWhere, showControls } = moduleState;
   const [stage, setStage] = useState<Stage | undefined>();
 
   const module = ModuleRepository.getModule(moduleId);
@@ -174,6 +176,7 @@ export const ModulePane = function ModulePane(props: ModulePaneProps) {
         timezone,
         where,
         setWhere,
+        moduleWhere,
         parameterValues: parameterValuesWithDefaults,
         setParameterValues: updateParameterValues,
         runSqlQuery,
@@ -191,15 +194,27 @@ export const ModulePane = function ModulePane(props: ModulePaneProps) {
     setModuleState(moduleState.applyShowMeasure(measure));
   }
 
+  const moduleHasFilter = !SqlLiteral.isTrue(moduleWhere);
   return (
     <div
       className={classNames(
         'module-pane',
         className,
         showControls ? 'show-controls' : 'no-controls',
+        showModuleWhere ? 'show-filter' : 'no-filter',
       )}
     >
-      <div className="module-top-bar">
+      {showModuleWhere && (
+        <FilterPane
+          querySource={querySource}
+          extraFilter={where}
+          timezone={timezone}
+          filter={moduleWhere}
+          onFilterChange={newFilter => setModuleState(moduleState.changeModuleWhere(newFilter))}
+          runSqlQuery={runSqlQuery}
+        />
+      )}
+      <div className="module-control-bar">
         <ModulePicker
           selectedModuleId={moduleId}
           onSelectedModuleIdChange={newModuleId => {
@@ -254,42 +269,49 @@ export const ModulePane = function ModulePane(props: ModulePaneProps) {
             onAddToSourceQueryAsMeasure={onAddToSourceQueryAsMeasure}
           />
         )}
-        <div className="bar-expander" />
-        <ButtonGroup>
-          <Popover
-            position={Position.BOTTOM_RIGHT}
-            content={
-              <Menu>
-                <MenuItem
-                  icon={IconNames.RESET}
-                  text="Reset visualization parameters"
-                  onClick={() => {
-                    setModuleState(
-                      moduleState.changeParameterValues(
-                        getStickyParameterValuesForModule(moduleId),
-                      ),
-                    );
-                  }}
-                />
-                <MenuItem
-                  icon={IconNames.TRASH}
-                  text="Delete module"
-                  intent={Intent.DANGER}
-                  onClick={onDelete}
-                />
-              </Menu>
-            }
-          >
-            <Button icon={IconNames.MORE} data-tooltip="More module options" minimal />
-          </Popover>
-          <Button
-            icon={IconNames.PROPERTIES}
-            data-tooltip={showControls ? 'Hide module controls' : 'Show module controls'}
-            minimal
-            onClick={() => setModuleState(moduleState.change({ showControls: !showControls }))}
-          />
-        </ButtonGroup>
       </div>
+      <ButtonGroup className="corner-buttons">
+        <Popover
+          position={Position.BOTTOM_RIGHT}
+          content={
+            <Menu>
+              <MenuItem
+                icon={IconNames.RESET}
+                text="Reset visualization parameters"
+                onClick={() => {
+                  setModuleState(
+                    moduleState.changeParameterValues(getStickyParameterValuesForModule(moduleId)),
+                  );
+                }}
+              />
+              <MenuItem
+                icon={IconNames.TRASH}
+                text="Delete module"
+                intent={Intent.DANGER}
+                onClick={onDelete}
+              />
+            </Menu>
+          }
+        >
+          <Button icon={IconNames.MORE} data-tooltip="More module options" minimal />
+        </Popover>
+        <Button
+          icon={moduleHasFilter ? IconNames.FILTER_KEEP : IconNames.FILTER}
+          data-tooltip={`${showModuleWhere ? 'Hide' : 'Show'} module filter bar${
+            moduleHasFilter ? `\nCurrent filter: ${moduleWhere}` : ''
+          }`}
+          minimal
+          active={showModuleWhere}
+          onClick={() => setModuleState(moduleState.change({ showModuleWhere: !showModuleWhere }))}
+        />
+        <Button
+          icon={IconNames.PROPERTIES}
+          data-tooltip={`${showControls ? 'Hide' : 'Show'} module controls`}
+          minimal
+          active={showControls}
+          onClick={() => setModuleState(moduleState.change({ showControls: !showControls }))}
+        />
+      </ButtonGroup>
       {showControls && module && (
         <div className="control-pane-container">
           <ControlPane
diff --git a/web-console/src/views/explore-view/components/preview-pane/preview-pane.scss b/web-console/src/views/explore-view/components/preview-pane/preview-pane.scss
index eff7363ad647..8749d7419a18 100644
--- a/web-console/src/views/explore-view/components/preview-pane/preview-pane.scss
+++ b/web-console/src/views/explore-view/components/preview-pane/preview-pane.scss
@@ -21,6 +21,12 @@
   display: flex;
   flex-direction: column;
 
+  .info-popover {
+    position: absolute;
+    top: 6px;
+    right: 6px;
+  }
+
   .preview-values-wrapper {
     flex: 1;
     position: relative;
diff --git a/web-console/src/views/explore-view/components/preview-pane/preview-pane.tsx b/web-console/src/views/explore-view/components/preview-pane/preview-pane.tsx
index 41bfd4bd14ac..bb70bda5544a 100644
--- a/web-console/src/views/explore-view/components/preview-pane/preview-pane.tsx
+++ b/web-console/src/views/explore-view/components/preview-pane/preview-pane.tsx
@@ -16,11 +16,14 @@
  * limitations under the License.
  */
 
-import { Callout } from '@blueprintjs/core';
+import { Button, Callout, Popover } from '@blueprintjs/core';
+import { IconNames } from '@blueprintjs/icons';
 import classNames from 'classnames';
 import type { QueryResult, SqlQuery } from 'druid-query-toolkit';
+import { dedupe } from 'druid-query-toolkit';
 import React from 'react';
 
+import { PopoverText } from '../../../../components';
 import { useQueryManager } from '../../../../hooks';
 import { formatEmpty } from '../../../../utils';
 
@@ -38,27 +41,35 @@ function getPreviewValues(queryResult: QueryResult): any[] {
 export interface PreviewPaneProps {
   previewQuery: string | undefined;
   runSqlQuery(query: string | SqlQuery): Promise<QueryResult>;
+  deduplicate?: boolean;
+  info?: string;
 }
 
 export const PreviewPane = React.memo(function PreviewPane(props: PreviewPaneProps) {
-  const { previewQuery, runSqlQuery } = props;
+  const { previewQuery, runSqlQuery, deduplicate, info } = props;
 
   const [previewState] = useQueryManager({
     query: previewQuery,
     processQuery: runSqlQuery,
-    debounceIdle: 1000,
+    debounceIdle: 2000,
+    debounceLoading: 3000,
   });
 
   const previewValues = previewState.data ? getPreviewValues(previewState.data) : undefined;
   return (
     <Callout className="preview-pane" title="Preview">
+      {info && (
+        <Popover className="info-popover" content={<PopoverText>{info}</PopoverText>}>
+          <Button icon={IconNames.INFO_SIGN} minimal />
+        </Popover>
+      )}
       {previewState.loading && 'Loading...'}
       {previewState.error && <div className="preview-error">{previewState.getErrorMessage()}</div>}
       {previewValues &&
         (previewValues.length ? (
           <div className="preview-values-wrapper">
             <div className="preview-values">
-              {previewValues.map((v, i) => (
+              {(deduplicate ? dedupe(previewValues) : previewValues).map((v, i) => (
                 <div
                   className={classNames('preview-value', { special: v == null || v === '' })}
                   key={i}
diff --git a/web-console/src/views/explore-view/components/resource-pane/column-dialog/column-dialog.tsx b/web-console/src/views/explore-view/components/resource-pane/column-dialog/column-dialog.tsx
index d220106ec76b..2ec95a4b9891 100644
--- a/web-console/src/views/explore-view/components/resource-pane/column-dialog/column-dialog.tsx
+++ b/web-console/src/views/explore-view/components/resource-pane/column-dialog/column-dialog.tsx
@@ -18,7 +18,7 @@
 
 import { Button, Classes, Dialog, FormGroup, InputGroup, Intent, Tag } from '@blueprintjs/core';
 import type { QueryResult, SqlQuery } from 'druid-query-toolkit';
-import { F, sql, SqlExpression } from 'druid-query-toolkit';
+import { F, SqlExpression } from 'druid-query-toolkit';
 import React, { useMemo, useState } from 'react';
 
 import { AppToaster } from '../../../../../singletons';
@@ -35,12 +35,14 @@ export interface ColumnDialogProps {
   columnToDuplicate?: string;
   onApply(newQuery: SqlQuery, rename: Rename | undefined): void;
   querySource: QuerySource;
+  where: SqlExpression;
   runSqlQuery(query: string | SqlQuery): Promise<QueryResult>;
   onClose(): void;
 }
 
 export const ColumnDialog = React.memo(function ColumnDialog(props: ColumnDialogProps) {
-  const { initExpression, columnToDuplicate, onApply, querySource, runSqlQuery, onClose } = props;
+  const { initExpression, columnToDuplicate, onApply, querySource, where, runSqlQuery, onClose } =
+    props;
 
   const [outputName, setOutputName] = useState(initExpression?.getOutputName() || '');
   const [formula, setFormula] = useState(String(initExpression?.getUnderlyingExpression() || ''));
@@ -48,15 +50,16 @@ export const ColumnDialog = React.memo(function ColumnDialog(props: ColumnDialog
   const previewQuery = useMemo(() => {
     const expression = SqlExpression.maybeParse(formula);
     if (!expression) return;
+
+    const expressionToPreview = F.cast(expression, 'VARCHAR');
     return querySource
       .getInitBaseQuery()
-      .addSelect(F.cast(expression, 'VARCHAR').as('v'), { addToGroupBy: 'end' })
-      .applyIf(querySource.hasBaseTimeColumn(), q =>
-        q.addWhere(sql`MAX_DATA_TIME() - INTERVAL '14' DAY <= __time`),
-      )
-      .changeLimitValue(100)
+      .addSelect(expressionToPreview.as('v'))
+      .addWhere(expressionToPreview.isNotNull())
+      .addWhere(querySource.transformExpressionToBaseColumns(where))
+      .changeLimitValue(200)
       .toString();
-  }, [querySource, formula]);
+  }, [querySource, formula, where]);
 
   return (
     <Dialog
@@ -90,7 +93,12 @@ export const ColumnDialog = React.memo(function ColumnDialog(props: ColumnDialog
             />
           </FormGroup>
         </div>
-        <PreviewPane previewQuery={previewQuery} runSqlQuery={runSqlQuery} />
+        <PreviewPane
+          previewQuery={previewQuery}
+          runSqlQuery={runSqlQuery}
+          deduplicate
+          info="The preview samples values for the column within the selected filter."
+        />
       </div>
       <div className={Classes.DIALOG_FOOTER}>
         <div className={Classes.DIALOG_FOOTER_ACTIONS}>
diff --git a/web-console/src/views/explore-view/components/resource-pane/measure-dialog/measure-dialog.tsx b/web-console/src/views/explore-view/components/resource-pane/measure-dialog/measure-dialog.tsx
index 308e2563ebf0..5299a5dca2ec 100644
--- a/web-console/src/views/explore-view/components/resource-pane/measure-dialog/measure-dialog.tsx
+++ b/web-console/src/views/explore-view/components/resource-pane/measure-dialog/measure-dialog.tsx
@@ -17,14 +17,7 @@
  */
 
 import { Button, Classes, Dialog, FormGroup, InputGroup, Intent, Tag } from '@blueprintjs/core';
-import {
-  L,
-  type QueryResult,
-  sql,
-  SqlExpression,
-  SqlQuery,
-  SqlWithPart,
-} from 'druid-query-toolkit';
+import { L, type QueryResult, SqlExpression, SqlQuery, SqlWithPart } from 'druid-query-toolkit';
 import React, { useMemo, useState } from 'react';
 
 import { AppToaster } from '../../../../../singletons';
@@ -40,12 +33,14 @@ export interface MeasureDialogProps {
   measureToDuplicate?: string;
   onApply(newQuery: SqlQuery, rename: Rename | undefined): void;
   querySource: QuerySource;
+  where: SqlExpression;
   runSqlQuery(query: string | SqlQuery): Promise<QueryResult>;
   onClose(): void;
 }
 
 export const MeasureDialog = React.memo(function MeasureDialog(props: MeasureDialogProps) {
-  const { initMeasure, measureToDuplicate, onApply, querySource, runSqlQuery, onClose } = props;
+  const { initMeasure, measureToDuplicate, onApply, querySource, where, runSqlQuery, onClose } =
+    props;
 
   const [outputName, setOutputName] = useState(initMeasure?.name || '');
   const [formula, setFormula] = useState(String(initMeasure?.expression || ''));
@@ -57,12 +52,9 @@ export const MeasureDialog = React.memo(function MeasureDialog(props: MeasureDia
       .changeWithParts([SqlWithPart.simple('t', QuerySource.stripToBaseSource(querySource.query))])
       .addSelect(L('Overall').as('label'))
       .addSelect(expression.as('value'))
-      .applyIf(querySource.hasBaseTimeColumn(), q =>
-        q.addWhere(sql`MAX_DATA_TIME() - INTERVAL '14' DAY <= __time`),
-      )
+      .changeWhereExpression(querySource.transformExpressionToBaseColumns(where))
       .toString();
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [querySource.query, formula]);
+  }, [querySource, formula, where]);
 
   return (
     <Dialog
@@ -96,7 +88,11 @@ export const MeasureDialog = React.memo(function MeasureDialog(props: MeasureDia
             />
           </FormGroup>
         </div>
-        <PreviewPane previewQuery={previewQuery} runSqlQuery={runSqlQuery} />
+        <PreviewPane
+          previewQuery={previewQuery}
+          runSqlQuery={runSqlQuery}
+          info="The preview shows the overal value for this measure within the selected filter."
+        />
       </div>
       <div className={Classes.DIALOG_FOOTER}>
         <div className={Classes.DIALOG_FOOTER_ACTIONS}>
diff --git a/web-console/src/views/explore-view/components/resource-pane/resource-pane.tsx b/web-console/src/views/explore-view/components/resource-pane/resource-pane.tsx
index 9c6146dfd1b1..068404a8853a 100644
--- a/web-console/src/views/explore-view/components/resource-pane/resource-pane.tsx
+++ b/web-console/src/views/explore-view/components/resource-pane/resource-pane.tsx
@@ -70,6 +70,7 @@ interface MeasureEditorOpenOn {
 export interface ResourcePaneProps {
   querySource: QuerySource;
   onQueryChange: (newQuery: SqlQuery, rename: Rename | undefined) => void;
+  where: SqlExpression;
   onFilter?: (column: Column) => void;
   onShowColumn(column: Column): void;
   onShowMeasure(measure: Measure): void;
@@ -77,7 +78,8 @@ export interface ResourcePaneProps {
 }
 
 export const ResourcePane = function ResourcePane(props: ResourcePaneProps) {
-  const { querySource, onQueryChange, onFilter, onShowColumn, onShowMeasure, runSqlQuery } = props;
+  const { querySource, onQueryChange, where, onFilter, onShowColumn, onShowMeasure, runSqlQuery } =
+    props;
   const [columnSearch, setColumnSearch] = useState('');
 
   const [columnEditorOpenOn, setColumnEditorOpenOn] = useState<ColumnEditorOpenOn | undefined>();
@@ -317,6 +319,7 @@ export const ResourcePane = function ResourcePane(props: ResourcePaneProps) {
           columnToDuplicate={columnEditorOpenOn.columnToDuplicate}
           onApply={onQueryChange}
           querySource={querySource}
+          where={where}
           runSqlQuery={runSqlQuery}
           onClose={() => setColumnEditorOpenOn(undefined)}
         />
@@ -336,6 +339,7 @@ export const ResourcePane = function ResourcePane(props: ResourcePaneProps) {
           measureToDuplicate={measureEditorOpenOn.measureToDuplicate}
           onApply={onQueryChange}
           querySource={querySource}
+          where={where}
           runSqlQuery={runSqlQuery}
           onClose={() => setMeasureEditorOpenOn(undefined)}
         />
diff --git a/web-console/src/views/explore-view/explore-view.scss b/web-console/src/views/explore-view/explore-view.scss
index 54a976f780db..d05418700897 100644
--- a/web-console/src/views/explore-view/explore-view.scss
+++ b/web-console/src/views/explore-view/explore-view.scss
@@ -72,6 +72,7 @@ $resources-width: 240px;
       .source-pane-container {
         padding: 8px 0;
         border-right: 1px solid $dark-gray2;
+        align-self: stretch;
       }
 
       .filter-pane {
diff --git a/web-console/src/views/explore-view/explore-view.tsx b/web-console/src/views/explore-view/explore-view.tsx
index 0d1624cbd7ff..fd5b43a51f11 100644
--- a/web-console/src/views/explore-view/explore-view.tsx
+++ b/web-console/src/views/explore-view/explore-view.tsx
@@ -36,7 +36,7 @@ import { Timezone } from 'chronoshift';
 import classNames from 'classnames';
 import copy from 'copy-to-clipboard';
 import type { Column, QueryResult, SqlExpression } from 'druid-query-toolkit';
-import { QueryRunner, SqlQuery } from 'druid-query-toolkit';
+import { QueryRunner, SqlLiteral, SqlQuery } from 'druid-query-toolkit';
 import React, { useEffect, useMemo, useRef, useState } from 'react';
 
 import { Loader, SplitterLayout, TimezoneMenuItems } from '../../components';
@@ -144,9 +144,7 @@ export const ExploreView = React.memo(function ExploreView() {
     '#explore/v/',
     LocalStorageKeys.EXPLORE_STATE,
     ExploreState.DEFAULT_STATE,
-    s => {
-      return ExploreState.fromJS(s);
-    },
+    s => ExploreState.fromJS(s),
   );
 
   // -------------------------------------------------------
@@ -321,6 +319,7 @@ export const ExploreView = React.memo(function ExploreView() {
               <FilterPane
                 ref={filterPane}
                 querySource={querySource}
+                extraFilter={SqlLiteral.TRUE}
                 timezone={timezone}
                 filter={where}
                 onFilterChange={setWhere}
@@ -329,7 +328,9 @@ export const ExploreView = React.memo(function ExploreView() {
                   if (!querySource) return;
                   setExploreState(
                     effectiveExploreState.changeSource(
-                      querySource.addColumn(querySource.transformToBaseColumns(expression)),
+                      querySource.addColumn(
+                        querySource.transformExpressionToBaseColumns(expression),
+                      ),
                       undefined,
                     ),
                   );
@@ -340,7 +341,9 @@ export const ExploreView = React.memo(function ExploreView() {
                     effectiveExploreState
                       .change({ where: changeWhere })
                       .changeSource(
-                        querySource.addWhereClause(querySource.transformToBaseColumns(expression)),
+                        querySource.addWhereClause(
+                          querySource.transformExpressionToBaseColumns(expression),
+                        ),
                         undefined,
                       ),
                   );
@@ -461,6 +464,7 @@ export const ExploreView = React.memo(function ExploreView() {
                     <ResourcePane
                       querySource={querySource}
                       onQueryChange={setSource}
+                      where={where}
                       onFilter={c => {
                         filterPane.current?.filterOn(c);
                       }}
@@ -502,7 +506,7 @@ export const ExploreView = React.memo(function ExploreView() {
                             setExploreState(
                               effectiveExploreState.changeSource(
                                 querySource.addColumn(
-                                  querySource.transformToBaseColumns(expression),
+                                  querySource.transformExpressionToBaseColumns(expression),
                                 ),
                                 undefined,
                               ),
@@ -514,7 +518,9 @@ export const ExploreView = React.memo(function ExploreView() {
                               effectiveExploreState.changeSource(
                                 querySource.addMeasure(
                                   measure.changeExpression(
-                                    querySource.transformToBaseColumns(measure.expression),
+                                    querySource.transformExpressionToBaseColumns(
+                                      measure.expression,
+                                    ),
                                   ),
                                 ),
                                 undefined,
diff --git a/web-console/src/views/explore-view/models/module-state.ts b/web-console/src/views/explore-view/models/module-state.ts
index 93959adea6d5..19230fc18afb 100644
--- a/web-console/src/views/explore-view/models/module-state.ts
+++ b/web-console/src/views/explore-view/models/module-state.ts
@@ -16,9 +16,9 @@
  * limitations under the License.
  */
 
-import type { Column, SqlExpression } from 'druid-query-toolkit';
+import type { Column } from 'druid-query-toolkit';
+import { SqlExpression, SqlLiteral } from 'druid-query-toolkit';
 
-import { isEmpty } from '../../../utils';
 import { ModuleRepository } from '../module-repository/module-repository';
 import type { Rename } from '../utils';
 
@@ -30,7 +30,9 @@ import type { QuerySource } from './query-source';
 
 interface ModuleStateValue {
   moduleId: string;
+  moduleWhere?: SqlExpression;
   parameterValues: ParameterValues;
+  showModuleWhere?: boolean;
   showControls?: boolean;
 }
 
@@ -44,17 +46,22 @@ export class ModuleState {
     );
     return new ModuleState({
       ...js,
+      moduleWhere: SqlExpression.maybeParse(js.moduleWhere),
       parameterValues: inflatedParameterValues,
     });
   }
 
   public readonly moduleId: string;
+  public readonly moduleWhere: SqlExpression;
   public readonly parameterValues: ParameterValues;
+  public readonly showModuleWhere: boolean;
   public readonly showControls: boolean;
 
   constructor(value: ModuleStateValue) {
     this.moduleId = value.moduleId;
+    this.moduleWhere = value.moduleWhere || SqlLiteral.TRUE;
     this.parameterValues = value.parameterValues;
+    this.showModuleWhere = Boolean(value.showModuleWhere);
     this.showControls = Boolean(value.showControls);
   }
 
@@ -63,6 +70,8 @@ export class ModuleState {
       moduleId: this.moduleId,
       parameterValues: this.parameterValues,
     };
+    if (!SqlLiteral.isTrue(this.moduleWhere)) value.moduleWhere = this.moduleWhere;
+    if (this.showModuleWhere) value.showModuleWhere = true;
     if (this.showControls) value.showControls = true;
     return value;
   }
@@ -74,6 +83,10 @@ export class ModuleState {
     });
   }
 
+  public changeModuleWhere(moduleWhere: SqlExpression): ModuleState {
+    return this.change({ moduleWhere });
+  }
+
   public changeParameterValues(parameterValues: ParameterValues): ModuleState {
     return this.change({ parameterValues });
   }
@@ -92,17 +105,19 @@ export class ModuleState {
   }
 
   public restrictToQuerySource(querySource: QuerySource, where: SqlExpression): ModuleState {
-    const { moduleId, parameterValues } = this;
+    const { moduleId, moduleWhere, parameterValues } = this;
     const module = ModuleRepository.getModule(moduleId);
     if (!module) return this;
+    const newModuleWhere = querySource.restrictWhere(moduleWhere);
     const newParameterValues = querySource.restrictParameterValues(
       parameterValues,
       module.parameters,
       where,
     );
-    if (parameterValues === newParameterValues) return this;
+    if (moduleWhere === newModuleWhere && parameterValues === newParameterValues) return this;
 
     return this.change({
+      moduleWhere: newModuleWhere,
       parameterValues: newParameterValues,
     });
   }
@@ -161,10 +176,6 @@ export class ModuleState {
       },
     });
   }
-
-  public isInitState(): boolean {
-    return this.moduleId === 'record-table' && isEmpty(this.parameterValues);
-  }
 }
 
 ModuleState.INIT_STATE = new ModuleState({
diff --git a/web-console/src/views/explore-view/models/parameter.ts b/web-console/src/views/explore-view/models/parameter.ts
index ed021da6f5b7..1929795bc199 100644
--- a/web-console/src/views/explore-view/models/parameter.ts
+++ b/web-console/src/views/explore-view/models/parameter.ts
@@ -108,6 +108,7 @@ export type TypedParameterDefinition<Type extends keyof ParameterTypes> = TypedE
   placeholder?: string;
   defined?: ModuleFunctor<boolean>;
   visible?: ModuleFunctor<boolean>;
+  legacyName?: string;
 };
 
 export type ParameterDefinition =
@@ -157,7 +158,11 @@ export function inflateParameterValues(
   parameters: Parameters,
 ): ParameterValues {
   return mapRecord(parameters, (parameter, parameterName) =>
-    inflateParameterValue(parameterValues?.[parameterName], parameter),
+    inflateParameterValue(
+      parameterValues?.[parameterName] ??
+        (parameter.legacyName ? parameterValues?.[parameter.legacyName] : undefined),
+      parameter,
+    ),
   );
 }
 
diff --git a/web-console/src/views/explore-view/models/query-source.ts b/web-console/src/views/explore-view/models/query-source.ts
index fa3f047426e1..cb67dbc89a93 100644
--- a/web-console/src/views/explore-view/models/query-source.ts
+++ b/web-console/src/views/explore-view/models/query-source.ts
@@ -224,7 +224,7 @@ export class QuerySource {
     );
   }
 
-  public transformToBaseColumns(expression: SqlExpression): SqlExpression {
+  public transformExpressionToBaseColumns(expression: SqlExpression): SqlExpression {
     const sourceToBaseSubstitutions = this.getSourceToBaseSubstitutions();
     return expression.walk(ex => {
       if (ex instanceof SqlColumn) {
diff --git a/web-console/src/views/explore-view/module-repository/module-repository.ts b/web-console/src/views/explore-view/module-repository/module-repository.ts
index 11bd25145a5c..698dcf036722 100644
--- a/web-console/src/views/explore-view/module-repository/module-repository.ts
+++ b/web-console/src/views/explore-view/module-repository/module-repository.ts
@@ -38,6 +38,7 @@ interface ModuleComponentProps<P> {
   timezone: Timezone;
   where: SqlExpression;
   setWhere(where: SqlExpression): void;
+  moduleWhere: SqlExpression;
   parameterValues: P;
   setParameterValues: (parameters: Partial<P>) => void;
   runSqlQuery(
diff --git a/web-console/src/views/explore-view/modules/bar-chart-module/bar-chart-module.tsx b/web-console/src/views/explore-view/modules/bar-chart-module/bar-chart-module.tsx
index bdf94e7196ea..6d08c77f9877 100644
--- a/web-console/src/views/explore-view/modules/bar-chart-module/bar-chart-module.tsx
+++ b/web-console/src/views/explore-view/modules/bar-chart-module/bar-chart-module.tsx
@@ -96,7 +96,16 @@ ModuleRepository.registerModule<BarChartParameterValues>({
     },
   },
   component: function BarChartModule(props) {
-    const { querySource, timezone, where, setWhere, parameterValues, stage, runSqlQuery } = props;
+    const {
+      querySource,
+      timezone,
+      where,
+      setWhere,
+      moduleWhere,
+      parameterValues,
+      stage,
+      runSqlQuery,
+    } = props;
     const containerRef = useRef<HTMLDivElement>();
     const chartRef = useRef<ECharts>();
     const [highlight, setHighlight] = useState<BarChartHighlight | undefined>();
@@ -108,7 +117,7 @@ ModuleRepository.registerModule<BarChartParameterValues>({
 
       return {
         query: querySource
-          .getInitQuery(where)
+          .getInitQuery(where.and(moduleWhere))
           .addSelect(
             splitExpression.applyIf(timeBucket, ex => F.timeFloor(ex, timeBucket)).as('dim'),
             {
@@ -127,7 +136,17 @@ ModuleRepository.registerModule<BarChartParameterValues>({
           .changeLimitValue(limit),
         timezone,
       };
-    }, [querySource, timezone, where, splitColumn, timeBucket, measure, measureToSort, limit]);
+    }, [
+      querySource,
+      timezone,
+      where,
+      moduleWhere,
+      splitColumn,
+      timeBucket,
+      measure,
+      measureToSort,
+      limit,
+    ]);
 
     const [sourceDataState, queryManager] = useQueryManager({
       query: dataQuery,
diff --git a/web-console/src/views/explore-view/modules/grouping-table-module/grouping-table-module.tsx b/web-console/src/views/explore-view/modules/grouping-table-module/grouping-table-module.tsx
index eeeee9252493..a06b6152722a 100644
--- a/web-console/src/views/explore-view/modules/grouping-table-module/grouping-table-module.tsx
+++ b/web-console/src/views/explore-view/modules/grouping-table-module/grouping-table-module.tsx
@@ -47,7 +47,7 @@ const NEEDS_GROUPING_TO_ORDER = true;
 
 interface QueryAndMore {
   timezone: Timezone;
-  originalWhere: SqlExpression;
+  globalWhere: SqlExpression;
   queryAndHints: QueryAndHints;
 }
 
@@ -213,6 +213,7 @@ ModuleRepository.registerModule<GroupingTableParameterValues>({
       timezone,
       where,
       setWhere,
+      moduleWhere,
       parameterValues,
       setParameterValues,
       runSqlQuery,
@@ -224,13 +225,13 @@ ModuleRepository.registerModule<GroupingTableParameterValues>({
       if (!pivotColumn) return;
 
       return querySource
-        .getInitQuery(where)
+        .getInitQuery(where.and(moduleWhere))
         .addSelect(pivotColumn.expression.as('v'), { addToGroupBy: 'end' })
         .changeOrderByExpression(
           (measures.length ? measures[0].expression : F.count()).toOrderByExpression('DESC'),
         )
         .changeLimitValue(maxPivotValues);
-    }, [querySource, where, parameterValues]);
+    }, [querySource, where, moduleWhere, parameterValues]);
 
     const [pivotValueState, queryManager] = useQueryManager({
       query: pivotValueQuery,
@@ -249,10 +250,10 @@ ModuleRepository.registerModule<GroupingTableParameterValues>({
 
       return {
         timezone,
-        originalWhere: where,
+        globalWhere: where,
         queryAndHints: makeTableQueryAndHints({
           source: querySource.query,
-          where,
+          where: where.and(moduleWhere),
           splitColumns: parameterValues.splitColumns,
           timeBucket: parameterValues.timeBucket,
           showColumns: parameterValues.showColumns,
@@ -274,13 +275,13 @@ ModuleRepository.registerModule<GroupingTableParameterValues>({
     const [resultState] = useQueryManager({
       query: queryAndMore,
       processQuery: async (queryAndMore, cancelToken) => {
-        const { timezone, originalWhere, queryAndHints } = queryAndMore;
+        const { timezone, globalWhere, queryAndHints } = queryAndMore;
         const { query, columnHints } = queryAndHints;
         let result = await runSqlQuery({ query, timezone }, cancelToken);
         if (result.sqlQuery) {
           result = result.attachQuery(
             { query: '' },
-            result.sqlQuery.changeWhereExpression(originalWhere),
+            result.sqlQuery.changeWhereExpression(globalWhere),
           );
         }
         return {
diff --git a/web-console/src/views/explore-view/modules/multi-axis-chart-module/multi-axis-chart-module.tsx b/web-console/src/views/explore-view/modules/multi-axis-chart-module/multi-axis-chart-module.tsx
index bffb93677aaa..2dff7e42eeb7 100644
--- a/web-console/src/views/explore-view/modules/multi-axis-chart-module/multi-axis-chart-module.tsx
+++ b/web-console/src/views/explore-view/modules/multi-axis-chart-module/multi-axis-chart-module.tsx
@@ -71,7 +71,16 @@ ModuleRepository.registerModule<MultiAxisChartParameterValues>({
     },
   },
   component: function MultiAxisChartModule(props) {
-    const { querySource, timezone, where, setWhere, parameterValues, stage, runSqlQuery } = props;
+    const {
+      querySource,
+      timezone,
+      where,
+      setWhere,
+      moduleWhere,
+      parameterValues,
+      stage,
+      runSqlQuery,
+    } = props;
     const containerRef = useRef<HTMLDivElement>();
     const chartRef = useRef<ECharts>();
     const [highlight, setHighlight] = useState<MultiAxisChartHighlight | undefined>();
@@ -87,7 +96,7 @@ ModuleRepository.registerModule<MultiAxisChartParameterValues>({
     const dataQuery = useMemo(() => {
       return {
         query: querySource
-          .getInitQuery(where)
+          .getInitQuery(where.and(moduleWhere))
           .addSelect(F.timeFloor(C(timeColumnName || '__time'), L(timeGranularity)).as('time'), {
             addToGroupBy: 'end',
             addToOrderBy: 'end',
@@ -96,7 +105,7 @@ ModuleRepository.registerModule<MultiAxisChartParameterValues>({
           .applyForEach(measures, (q, measure) => q.addSelect(measure.expression.as(measure.name))),
         timezone,
       };
-    }, [querySource, timezone, where, timeColumnName, timeGranularity, measures]);
+    }, [querySource, timezone, where, moduleWhere, timeColumnName, timeGranularity, measures]);
 
     const [sourceDataState, queryManager] = useQueryManager({
       query: dataQuery,
diff --git a/web-console/src/views/explore-view/modules/pie-chart-module/pie-chart-module.tsx b/web-console/src/views/explore-view/modules/pie-chart-module/pie-chart-module.tsx
index 69c9b9278799..b98c876fb334 100644
--- a/web-console/src/views/explore-view/modules/pie-chart-module/pie-chart-module.tsx
+++ b/web-console/src/views/explore-view/modules/pie-chart-module/pie-chart-module.tsx
@@ -97,7 +97,8 @@ ModuleRepository.registerModule<PieChartParameterValues>({
     },
   },
   component: function PieChartModule(props) {
-    const { querySource, where, setWhere, parameterValues, stage, runSqlQuery } = props;
+    const { querySource, where, setWhere, moduleWhere, parameterValues, stage, runSqlQuery } =
+      props;
     const containerRef = useRef<HTMLDivElement>();
     const chartRef = useRef<ECharts>();
     const [highlight, setHighlight] = useState<PieChartHighlight | undefined>();
@@ -106,34 +107,43 @@ ModuleRepository.registerModule<PieChartParameterValues>({
 
     const dataQueries = useMemo(() => {
       const splitExpression = splitColumn ? splitColumn.expression : L(OVERALL_LABEL);
+      const effectiveWhere = where.and(moduleWhere);
 
       return {
         mainQuery: querySource
-          .getInitQuery(where)
+          .getInitQuery(effectiveWhere)
           .addSelect(F.cast(splitExpression, 'VARCHAR').as('name'), { addToGroupBy: 'end' })
           .addSelect(measure.expression.as('value'), {
             addToOrderBy: 'end',
             direction: 'DESC',
           })
-          .changeLimitValue(limit),
+          .changeLimitValue(limit + (showOthers ? 1 : 0)),
+        limit,
         splitExpression: splitColumn?.expression,
         othersPartialQuery: showOthers
-          ? querySource.getInitQuery(where).addSelect(measure.expression.as('value'))
+          ? querySource.getInitQuery(effectiveWhere).addSelect(measure.expression.as('value'))
           : undefined,
       };
-    }, [querySource, where, splitColumn, measure, limit, showOthers]);
+    }, [querySource, where, moduleWhere, splitColumn, measure, limit, showOthers]);
 
     const [sourceDataState, queryManager] = useQueryManager({
       query: dataQueries,
-      processQuery: async ({ mainQuery, splitExpression, othersPartialQuery }, cancelToken) => {
+      processQuery: async (
+        { mainQuery, limit, splitExpression, othersPartialQuery },
+        cancelToken,
+      ) => {
         const result = await runSqlQuery({ query: mainQuery }, cancelToken);
         const data = result.toObjectArray();
 
         if (splitExpression && othersPartialQuery) {
-          const othersResult = await runSqlQuery({
-            query: othersPartialQuery.addWhere(splitExpression.notIn(result.getColumnByIndex(0)!)),
-          });
-          data.push({ name: 'Others', value: othersResult.rows[0][0], __isOthers: true });
+          const pieValues = result.getColumnByIndex(0)!;
+
+          if (pieValues.length > limit) {
+            const othersResult = await runSqlQuery({
+              query: othersPartialQuery.addWhere(splitExpression.notIn(pieValues.slice(0, limit))),
+            });
+            data.push({ name: 'Others', value: othersResult.rows[0][0], __isOthers: true });
+          }
         }
 
         return data;
diff --git a/web-console/src/views/explore-view/modules/record-table-module/record-table-module.tsx b/web-console/src/views/explore-view/modules/record-table-module/record-table-module.tsx
index c9d842dfb9c1..822f01c329ee 100644
--- a/web-console/src/views/explore-view/modules/record-table-module/record-table-module.tsx
+++ b/web-console/src/views/explore-view/modules/record-table-module/record-table-module.tsx
@@ -67,11 +67,20 @@ ModuleRepository.registerModule<RecordTableParameterValues>({
     },
   },
   component: function RecordTableModule(props) {
-    const { stage, querySource, timezone, where, setWhere, parameterValues, runSqlQuery } = props;
+    const {
+      stage,
+      querySource,
+      timezone,
+      where,
+      setWhere,
+      moduleWhere,
+      parameterValues,
+      runSqlQuery,
+    } = props;
 
     const query = useMemo((): string | undefined => {
       return SqlQuery.create(querySource.query)
-        .changeWhereExpression(where)
+        .changeWhereExpression(where.and(moduleWhere))
         .changeLimitValue(parameterValues.maxRows)
         .applyIf(
           querySource.columns.some(e => e.name === '__time') && !parameterValues.ascending,
@@ -79,7 +88,7 @@ ModuleRepository.registerModule<RecordTableParameterValues>({
           q => q.changeOrderByClause(querySource.query.orderByClause),
         )
         .toString();
-    }, [querySource, where, parameterValues]);
+    }, [querySource, where, moduleWhere, parameterValues]);
 
     const [resultState, queryManager] = useQueryManager({
       query,
diff --git a/web-console/src/views/explore-view/modules/time-chart-module/continuous-chart-render.scss b/web-console/src/views/explore-view/modules/time-chart-module/continuous-chart-render.scss
index 5f7be42df956..63f237580914 100644
--- a/web-console/src/views/explore-view/modules/time-chart-module/continuous-chart-render.scss
+++ b/web-console/src/views/explore-view/modules/time-chart-module/continuous-chart-render.scss
@@ -18,6 +18,8 @@
 
 @import '../../../../variables';
 
+$default-chart-color: $druid-brand;
+
 .continuous-chart-render {
   position: relative;
   overflow: hidden;
@@ -30,10 +32,6 @@
       user-select: none;
     }
 
-    .mark-bar {
-      fill: #497ee6;
-    }
-
     .selection {
       fill: white;
       fill-opacity: 0.1;
@@ -89,25 +87,29 @@
       opacity: 0.7;
     }
 
+    .mark-bar {
+      fill: #00b6c3;
+    }
+
     .mark-line {
       stroke-width: 1.5px;
-      stroke: #497ee6;
+      stroke: $default-chart-color;
       fill: none;
     }
 
     .mark-area {
-      fill: #497ee6;
-      opacity: 0.7;
+      fill: $default-chart-color;
+      opacity: 0.5;
     }
 
     .single-point {
-      stroke: #497ee6;
+      stroke: $default-chart-color;
       opacity: 0.7;
       stroke-width: 1.5px;
     }
 
     .selected-point {
-      fill: #497ee6;
+      fill: $default-chart-color;
     }
   }
 
diff --git a/web-console/src/views/explore-view/modules/time-chart-module/continuous-chart-render.tsx b/web-console/src/views/explore-view/modules/time-chart-module/continuous-chart-render.tsx
index 378c652142e8..c0d759530d50 100644
--- a/web-console/src/views/explore-view/modules/time-chart-module/continuous-chart-render.tsx
+++ b/web-console/src/views/explore-view/modules/time-chart-module/continuous-chart-render.tsx
@@ -42,6 +42,7 @@ import {
   formatStartDuration,
   groupBy,
   lookupBy,
+  minBy,
   tickFormatWithTimezone,
   timezoneAwareTicks,
 } from '../../../../utils';
@@ -73,7 +74,7 @@ export interface RangeDatum {
   start: number;
   end: number;
   measure: number;
-  stack: string | undefined;
+  facet: string | undefined;
 }
 
 export interface StackedRangeDatum extends RangeDatum {
@@ -126,7 +127,7 @@ export interface ContinuousChartRenderProps {
    * If stacking is used then the stack bars should be ordered bottom to top.
    */
   data: RangeDatum[];
-  stacks: string[] | undefined;
+  facets: string[] | undefined;
 
   /**
    * The granularity that was used for bucketing.
@@ -161,7 +162,7 @@ export const ContinuousChartRender = function ContinuousChartRender(
 ) {
   const {
     data,
-    stacks,
+    facets,
     granularity,
 
     markType,
@@ -199,10 +200,10 @@ export const ContinuousChartRender = function ContinuousChartRender(
   const svgRef = useRef<SVGSVGElement | null>(null);
 
   const stackedData: StackedRangeDatum[] = useMemo(() => {
-    const effectiveStacks = stacks || ['undefined'];
-    const stackToIndex = lookupBy(
-      effectiveStacks,
-      s => s,
+    const effectiveFacet = facets || ['undefined'];
+    const facetToIndex = lookupBy(
+      effectiveFacet,
+      f => f,
       (_, i) => i,
     );
 
@@ -211,7 +212,7 @@ export const ContinuousChartRender = function ContinuousChartRender(
       const diffStart = b.start - a.start;
       if (diffStart) return diffStart;
 
-      return stackToIndex[String(a.stack)] - stackToIndex[String(b.stack)];
+      return facetToIndex[String(a.facet)] - facetToIndex[String(b.facet)];
     });
 
     if (markType === 'line') {
@@ -230,18 +231,26 @@ export const ContinuousChartRender = function ContinuousChartRender(
         return withOffset;
       });
     }
-  }, [data, stacks, markType]);
+  }, [data, facets, markType]);
 
-  function findStackedDatum(time: number, measure: number): StackedRangeDatum | undefined {
+  function findStackedDatum(
+    time: number,
+    measure: number,
+    isStacked: boolean,
+  ): StackedRangeDatum | undefined {
     const dataInRange = stackedData.filter(d => d.start <= time && time < d.end);
     if (!dataInRange.length) return;
-    return (
-      dataInRange.find(r => r.offset <= measure && measure < r.measure + r.offset) ||
-      dataInRange[dataInRange.length - 1]
-    );
+    if (isStacked) {
+      return (
+        dataInRange.find(r => r.offset <= measure && measure < r.measure + r.offset) ||
+        dataInRange[dataInRange.length - 1]
+      );
+    } else {
+      return minBy(dataInRange, r => Math.abs(r.measure - measure));
+    }
   }
 
-  const stackColorizer = useMemo(() => {
+  const facetColorizer = useMemo(() => {
     const s = scaleOrdinal(COLORS);
     return (v: string) => (v === OTHER_VALUE ? OTHER_COLOR : s(v));
   }, []);
@@ -342,7 +351,7 @@ export const ContinuousChartRender = function ContinuousChartRender(
         setSelectionIfNeeded({
           start: start.valueOf(),
           end: end.valueOf(),
-          selectedDatum: findStackedDatum(time, measure),
+          selectedDatum: findStackedDatum(time, measure, markType !== 'line'),
         });
       } else {
         setSelection(undefined);
@@ -389,40 +398,43 @@ export const ContinuousChartRender = function ContinuousChartRender(
     }
   });
 
-  const byStack = useMemo(() => {
+  const byFacet = useMemo(() => {
     if (markType === 'bar' || !stackedData.length) return [];
+    const isStacked = markType !== 'line';
 
-    const effectiveStacks = stacks || ['undefined'];
-    const numStacks = effectiveStacks.length;
+    const effectiveFacets = facets || ['undefined'];
+    const numFacets = effectiveFacets.length;
 
-    // Fill in 0s and make sure that the stacks are in the same order
+    // Fill in 0s and make sure that the facets are in the same order
     const fullTimeIntervals = groupBy(
       stackedData,
       d => String(d.start),
       dataForStart => {
-        if (numStacks === 1) return [dataForStart[0]];
-        const stackToDatum = lookupBy(dataForStart, d => d.stack!);
-        return effectiveStacks.map(
-          (stack, stackIndex) =>
-            stackToDatum[stack] || {
+        if (numFacets === 1) return [dataForStart[0]];
+        const facetToDatum = lookupBy(dataForStart, d => d.facet!);
+        return effectiveFacets.map(
+          (facet, facetIndex) =>
+            facetToDatum[facet] || {
               ...dataForStart[0],
-              stack,
+              facet,
               measure: 0,
-              offset: Math.max(
-                0,
-                ...filterMap(effectiveStacks.slice(0, stackIndex), s => stackToDatum[s]).map(
-                  d => d.offset + d.measure,
-                ),
-              ),
+              offset: isStacked
+                ? Math.max(
+                    0,
+                    ...filterMap(effectiveFacets.slice(0, facetIndex), s => facetToDatum[s]).map(
+                      d => d.offset + d.measure,
+                    ),
+                  )
+                : 0,
             },
         );
       },
     );
 
     // Add nulls to mark gaps in data
-    const seriesForStack: Record<string, (StackedRangeDatum | null)[]> = {};
-    for (const stack of effectiveStacks) {
-      seriesForStack[stack] = [];
+    const seriesForFacet: Record<string, (StackedRangeDatum | null)[]> = {};
+    for (const stack of effectiveFacets) {
+      seriesForFacet[stack] = [];
     }
 
     let lastDatum: StackedRangeDatum | undefined;
@@ -430,19 +442,19 @@ export const ContinuousChartRender = function ContinuousChartRender(
       const datum = fullTimeInterval[0];
 
       if (lastDatum && lastDatum.start !== datum.end) {
-        for (const stack of effectiveStacks) {
-          seriesForStack[stack].push(null);
+        for (const facet of effectiveFacets) {
+          seriesForFacet[facet].push(null);
         }
       }
 
-      for (let i = 0; i < numStacks; i++) {
-        seriesForStack[effectiveStacks[i]].push(fullTimeInterval[i]);
+      for (let i = 0; i < numFacets; i++) {
+        seriesForFacet[effectiveFacets[i]].push(fullTimeInterval[i]);
       }
       lastDatum = datum;
     }
 
-    return Object.values(seriesForStack);
-  }, [markType, stackedData, stacks]);
+    return Object.values(seriesForFacet);
+  }, [markType, stackedData, facets]);
 
   if (innerStage.isInvalid()) return;
 
@@ -531,7 +543,7 @@ export const ContinuousChartRender = function ContinuousChartRender(
       title,
       text: (
         <>
-          {selectedDatum?.stack && <div>{selectedDatum?.stack}</div>}
+          {selectedDatum?.facet && <div>{selectedDatum?.facet}</div>}
           <div>{info}</div>
           {selection.finalized && (
             <div className="button-bar">
@@ -605,13 +617,13 @@ export const ContinuousChartRender = function ContinuousChartRender(
                 if (!r) return;
                 return (
                   <rect
-                    key={`${stackedRow.start}/${stackedRow.end}/${stackedRow.stack}`}
+                    key={`${stackedRow.start}/${stackedRow.end}/${stackedRow.facet}`}
                     className="mark-bar"
                     {...r}
                     style={
-                      typeof stackedRow.stack !== 'undefined'
+                      typeof stackedRow.facet !== 'undefined'
                         ? {
-                            fill: stackColorizer(stackedRow.stack),
+                            fill: facetColorizer(stackedRow.facet),
                           }
                         : undefined
                     }
@@ -625,17 +637,17 @@ export const ContinuousChartRender = function ContinuousChartRender(
               />
             )}
             {markType === 'area' &&
-              byStack.map(ds => {
-                const stack = ds[0]!.stack;
+              byFacet.map(ds => {
+                const facet = ds[0]!.facet;
                 return (
                   <path
-                    key={String(stack)}
+                    key={String(facet)}
                     className="mark-area"
                     d={areaFn(ds)!}
                     style={
-                      typeof stack !== 'undefined'
+                      typeof facet !== 'undefined'
                         ? {
-                            fill: stackColorizer(stack),
+                            fill: facetColorizer(facet),
                           }
                         : undefined
                     }
@@ -643,17 +655,17 @@ export const ContinuousChartRender = function ContinuousChartRender(
                 );
               })}
             {(markType === 'area' || markType === 'line') &&
-              byStack.map(ds => {
-                const stack = ds[0]!.stack;
+              byFacet.map(ds => {
+                const facet = ds[0]!.facet;
                 return (
                   <path
-                    key={String(stack)}
+                    key={String(facet)}
                     className="mark-line"
                     d={lineFn(ds)!}
                     style={
-                      typeof stack !== 'undefined'
+                      typeof facet !== 'undefined'
                         ? {
-                            stroke: stackColorizer(stack),
+                            stroke: facetColorizer(facet),
                           }
                         : undefined
                     }
@@ -661,22 +673,22 @@ export const ContinuousChartRender = function ContinuousChartRender(
                 );
               })}
             {(markType === 'area' || markType === 'line') &&
-              byStack.flatMap(ds =>
+              byFacet.flatMap(ds =>
                 filterMap(ds, (d, i) => {
                   if (!d || ds[i - 1] || ds[i + 1]) return; // Not a single point
                   const x = timeScale((d.start + d.end) / 2);
                   return (
                     <line
-                      key={`single_${i}_${d.stack}`}
+                      key={`single_${i}_${d.facet}`}
                       className="single-point"
                       x1={x}
                       x2={x}
                       y1={measureScale(d.measure + d.offset)}
                       y2={measureScale(d.offset)}
                       style={
-                        typeof d.stack !== 'undefined'
+                        typeof d.facet !== 'undefined'
                           ? {
-                              stroke: stackColorizer(d.stack),
+                              stroke: facetColorizer(d.facet),
                             }
                           : undefined
                       }
@@ -690,9 +702,9 @@ export const ContinuousChartRender = function ContinuousChartRender(
                 {...datumToCxCy(selection.selectedDatum)}
                 r={3}
                 style={
-                  typeof selection.selectedDatum.stack !== 'undefined'
+                  typeof selection.selectedDatum.facet !== 'undefined'
                     ? {
-                        fill: stackColorizer(selection.selectedDatum.stack),
+                        fill: facetColorizer(selection.selectedDatum.facet),
                       }
                     : undefined
                 }
diff --git a/web-console/src/views/explore-view/modules/time-chart-module/time-chart-module.tsx b/web-console/src/views/explore-view/modules/time-chart-module/time-chart-module.tsx
index 5ac00a310d05..cd97284a770c 100644
--- a/web-console/src/views/explore-view/modules/time-chart-module/time-chart-module.tsx
+++ b/web-console/src/views/explore-view/modules/time-chart-module/time-chart-module.tsx
@@ -45,7 +45,7 @@ import { ContinuousChartRender, OTHER_VALUE } from './continuous-chart-render';
 
 const TIME_NAME = 't';
 const MEASURE_NAME = 'm';
-const STACK_NAME = 's';
+const FACET_NAME = 'f';
 const MIN_SLICE_WIDTH = 8;
 
 function getRangeInExpression(
@@ -92,12 +92,12 @@ function getRangeInExpression(
 }
 
 interface TimeChartParameterValues {
+  markType: ContinuousChartMarkType;
   granularity: string;
-  splitColumn?: ExpressionMeta;
-  numberToStack: number;
+  facetColumn?: ExpressionMeta;
+  maxFacets: number;
   showOthers: boolean;
   measure: ExpressionMeta;
-  markType: ContinuousChartMarkType;
   curveType: ContinuousChartCurveType;
 }
 
@@ -106,6 +106,12 @@ ModuleRepository.registerModule<TimeChartParameterValues>({
   title: 'Time chart',
   icon: IconNames.TIMELINE_LINE_CHART,
   parameters: {
+    markType: {
+      type: 'option',
+      options: ['line', 'area', 'bar'],
+      defaultValue: 'line',
+      optionLabels: capitalizeFirst,
+    },
     granularity: {
       type: 'option',
       options: ({ querySource, where }) => {
@@ -132,24 +138,25 @@ ModuleRepository.registerModule<TimeChartParameterValues>({
       important: true,
       optionLabels: g => (g === 'auto' ? 'Auto' : new Duration(g).getDescription(true)),
     },
-    splitColumn: {
+    facetColumn: {
       type: 'expression',
-      label: 'Stack by',
+      label: 'Facet by',
       transferGroup: 'show',
       important: true,
+      legacyName: 'splitColumn',
     },
-    numberToStack: {
+    maxFacets: {
       type: 'number',
-      label: 'Max stacks',
       defaultValue: 7,
-      min: 2,
+      min: 1,
       required: true,
-      visible: ({ parameterValues }) => Boolean(parameterValues.splitColumn),
+      visible: ({ parameterValues }) => Boolean(parameterValues.facetColumn),
+      legacyName: 'numberToStack',
     },
     showOthers: {
       type: 'boolean',
       defaultValue: true,
-      visible: ({ parameterValues }) => Boolean(parameterValues.splitColumn),
+      visible: ({ parameterValues }) => Boolean(parameterValues.facetColumn),
     },
     measure: {
       type: 'measure',
@@ -159,12 +166,6 @@ ModuleRepository.registerModule<TimeChartParameterValues>({
       defaultValue: ({ querySource }) => querySource?.getFirstAggregateMeasure(),
       required: true,
     },
-    markType: {
-      type: 'option',
-      options: ['area', 'bar', 'line'],
-      defaultValue: 'area',
-      optionLabels: capitalizeFirst,
-    },
     curveType: {
       type: 'option',
       options: ['smooth', 'linear', 'step'],
@@ -174,7 +175,16 @@ ModuleRepository.registerModule<TimeChartParameterValues>({
     },
   },
   component: function TimeChartModule(props) {
-    const { querySource, timezone, where, setWhere, parameterValues, stage, runSqlQuery } = props;
+    const {
+      querySource,
+      timezone,
+      where,
+      setWhere,
+      moduleWhere,
+      parameterValues,
+      stage,
+      runSqlQuery,
+    } = props;
 
     const timeColumnName = querySource.columns.find(column => column.sqlType === 'TIMESTAMP')?.name;
     const timeGranularity =
@@ -186,17 +196,18 @@ ModuleRepository.registerModule<TimeChartParameterValues>({
           )
         : parameterValues.granularity;
 
-    const { splitColumn, numberToStack, showOthers, measure, markType } = parameterValues;
+    const { facetColumn, maxFacets, showOthers, measure, markType } = parameterValues;
 
     const dataQuery = useMemo(() => {
       return {
         querySource,
         timezone,
         where,
+        moduleWhere,
         timeGranularity,
         measure,
-        splitExpression: splitColumn?.expression,
-        numberToStack,
+        facetExpression: facetColumn?.expression,
+        maxFacets,
         showOthers,
         oneExtra: markType !== 'bar',
       };
@@ -204,10 +215,11 @@ ModuleRepository.registerModule<TimeChartParameterValues>({
       querySource,
       timezone,
       where,
+      moduleWhere,
       timeGranularity,
       measure,
-      splitColumn,
-      numberToStack,
+      facetColumn,
+      maxFacets,
       showOthers,
       markType,
     ]);
@@ -219,10 +231,11 @@ ModuleRepository.registerModule<TimeChartParameterValues>({
           querySource,
           timezone,
           where,
+          moduleWhere,
           timeGranularity,
           measure,
-          splitExpression,
-          numberToStack,
+          facetExpression,
+          maxFacets,
           showOthers,
           oneExtra,
         },
@@ -232,17 +245,20 @@ ModuleRepository.registerModule<TimeChartParameterValues>({
           throw new Error(`Must have a column of type TIMESTAMP for the time chart to work`);
         }
 
+        const effectiveWhere = where.and(moduleWhere);
         const granularity = new Duration(timeGranularity);
 
-        const vs = splitExpression
+        const detectedFacets: string[] | undefined = facetExpression
           ? (
               await runSqlQuery(
                 {
                   query: querySource
-                    .getInitQuery(where)
-                    .addSelect(splitExpression.cast('VARCHAR').as('v'), { addToGroupBy: 'end' })
+                    .getInitQuery(effectiveWhere)
+                    .addSelect(facetExpression.cast('VARCHAR').as(FACET_NAME), {
+                      addToGroupBy: 'end',
+                    })
                     .changeOrderByExpression(measure.expression.toOrderByExpression('DESC'))
-                    .changeLimitValue(numberToStack),
+                    .changeLimitValue(maxFacets + (showOthers ? 1 : 0)), // If we want to show others add 1 to check if we need to query for them
                   timezone,
                 },
                 cancelToken,
@@ -252,44 +268,54 @@ ModuleRepository.registerModule<TimeChartParameterValues>({
 
         cancelToken.throwIfRequested();
 
-        if (vs?.length === 0) {
-          // If vs is empty then there is no data at all and no need to do a larger query
+        if (detectedFacets?.length === 0) {
+          // If detectedFacets is empty then there is no data at all and no need to do a larger query
           return {
-            effectiveVs: [],
+            effectiveFacets: [],
             sourceData: [],
             measure,
             granularity,
           };
         }
 
-        const effectiveVs = vs && showOthers ? vs.concat(OTHER_VALUE) : vs;
+        const facetsToQuery =
+          showOthers && detectedFacets && maxFacets < detectedFacets.length
+            ? detectedFacets.slice(0, maxFacets)
+            : undefined;
+        const effectiveFacets = facetsToQuery ? facetsToQuery.concat(OTHER_VALUE) : detectedFacets;
 
         const result = await runSqlQuery(
           {
             query: querySource
-              .getInitQuery(overqueryWhere(where, timeColumnName, granularity, oneExtra))
-              .applyIf(splitExpression && vs && !showOthers, q =>
-                q.addWhere(splitExpression!.cast('VARCHAR').in(vs!)),
+              .getInitQuery(overqueryWhere(effectiveWhere, timeColumnName, granularity, oneExtra))
+              .applyIf(facetExpression && detectedFacets && !facetsToQuery, q =>
+                q.addWhere(facetExpression!.cast('VARCHAR').in(detectedFacets!)),
               )
               .addSelect(F.timeFloor(C(timeColumnName), L(timeGranularity)).as(TIME_NAME), {
                 addToGroupBy: 'end',
                 addToOrderBy: 'end',
                 direction: 'DESC',
               })
-              .applyIf(splitExpression, q => {
-                if (!splitExpression || !vs) return q; // Should never get here, doing this to make peace between eslint and TS
+              .applyIf(facetExpression, q => {
+                if (!facetExpression) return q; // Should never get here, doing this to make peace between eslint and TS
                 return q.addSelect(
-                  (showOthers
-                    ? SqlCase.ifThenElse(splitExpression.in(vs), splitExpression, L(OTHER_VALUE))
-                    : splitExpression
+                  (facetsToQuery
+                    ? SqlCase.ifThenElse(
+                        facetExpression.in(facetsToQuery),
+                        facetExpression,
+                        L(OTHER_VALUE),
+                      )
+                    : facetExpression
                   )
                     .cast('VARCHAR')
-                    .as(STACK_NAME),
+                    .as(FACET_NAME),
                   { addToGroupBy: 'end' },
                 );
               })
               .addSelect(measure.expression.as(MEASURE_NAME))
-              .changeLimitValue(10000 * (effectiveVs ? Math.min(effectiveVs.length, 10) : 1)),
+              .changeLimitValue(
+                10000 * (effectiveFacets ? Math.min(effectiveFacets.length, 10) : 1),
+              ),
             timezone,
           },
           cancelToken,
@@ -300,12 +326,12 @@ ModuleRepository.registerModule<TimeChartParameterValues>({
             start: b[TIME_NAME].valueOf(),
             end: granularity.shift(b[TIME_NAME], Timezone.UTC, 1).valueOf(),
             measure: b[MEASURE_NAME],
-            stack: b[STACK_NAME],
+            facet: b[FACET_NAME],
           }),
         );
 
         return {
-          effectiveVs,
+          effectiveFacets,
           sourceData: dataset,
           measure,
           granularity,
@@ -326,7 +352,7 @@ ModuleRepository.registerModule<TimeChartParameterValues>({
         {sourceData && (
           <ContinuousChartRender
             data={sourceData.sourceData}
-            stacks={sourceData.effectiveVs}
+            facets={sourceData.effectiveFacets}
             granularity={sourceData.granularity}
             markType={parameterValues.markType}
             curveType={parameterValues.curveType}

From 2bca650834742848004218a63dd78e82257dd8a1 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Mon, 31 Mar 2025 00:56:07 -0700
Subject: [PATCH 68/99] update TestSegmentCacheManager

---
 .../druid/testing/tools/ServerManagerForQueryErrorTest.java      | 1 -
 .../server/coordination/ServerManagerForQueryErrorTest.java      | 1 -
 .../druid/server/coordination/SegmentLoadDropHandlerTest.java    | 1 +
 3 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/integration-tests-ex/tools/src/main/java/org/apache/druid/testing/tools/ServerManagerForQueryErrorTest.java b/integration-tests-ex/tools/src/main/java/org/apache/druid/testing/tools/ServerManagerForQueryErrorTest.java
index e3b3806b0199..2fc2391cd541 100644
--- a/integration-tests-ex/tools/src/main/java/org/apache/druid/testing/tools/ServerManagerForQueryErrorTest.java
+++ b/integration-tests-ex/tools/src/main/java/org/apache/druid/testing/tools/ServerManagerForQueryErrorTest.java
@@ -51,7 +51,6 @@
 import org.apache.druid.server.SegmentManager;
 import org.apache.druid.server.coordination.ServerManager;
 import org.apache.druid.server.initialization.ServerConfig;
-import org.apache.druid.server.security.AuthConfig;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 
 import java.util.HashSet;
diff --git a/integration-tests/src/main/java/org/apache/druid/server/coordination/ServerManagerForQueryErrorTest.java b/integration-tests/src/main/java/org/apache/druid/server/coordination/ServerManagerForQueryErrorTest.java
index 1e5032c1c126..1282a7d78337 100644
--- a/integration-tests/src/main/java/org/apache/druid/server/coordination/ServerManagerForQueryErrorTest.java
+++ b/integration-tests/src/main/java/org/apache/druid/server/coordination/ServerManagerForQueryErrorTest.java
@@ -46,7 +46,6 @@
 import org.apache.druid.query.ResourceLimitExceededException;
 import org.apache.druid.query.SegmentDescriptor;
 import org.apache.druid.query.policy.NoopPolicyEnforcer;
-import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.ReferenceCountingSegment;
 import org.apache.druid.segment.SegmentReference;
 import org.apache.druid.server.SegmentManager;
diff --git a/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java b/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
index 99a2a1f7ad46..a3cd6c4962aa 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
@@ -31,6 +31,7 @@
 import org.apache.druid.server.SegmentManager;
 import org.apache.druid.server.coordination.SegmentChangeStatus.State;
 import org.apache.druid.server.http.SegmentLoadingMode;
+import org.apache.druid.test.utils.TestSegmentCacheManager;
 import org.apache.druid.timeline.DataSegment;
 import org.junit.Assert;
 import org.junit.Before;

From 159f50e2657975c08429f6a1687e156ea5a465a7 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Mon, 31 Mar 2025 16:50:51 -0700
Subject: [PATCH 69/99] revert some style changes

---
 .../coordination/SegmentBootstrapperTest.java | 19 ++++---------------
 1 file changed, 4 insertions(+), 15 deletions(-)

diff --git a/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperTest.java b/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperTest.java
index 4c543faec9b4..25ce9a22d153 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperTest.java
@@ -188,11 +188,7 @@ public void testLoadCachedSegments() throws Exception
 
     final TestSegmentCacheManager cacheManager = new TestSegmentCacheManager(segments);
     final SegmentManager segmentManager = new SegmentManager(cacheManager);
-    final SegmentLoadDropHandler handler = new SegmentLoadDropHandler(
-        segmentLoaderConfig,
-        segmentAnnouncer,
-        segmentManager
-    );
+    final SegmentLoadDropHandler handler = new SegmentLoadDropHandler(segmentLoaderConfig, segmentAnnouncer, segmentManager);
     final SegmentBootstrapper bootstrapper = new SegmentBootstrapper(
         handler,
         segmentLoaderConfig,
@@ -304,10 +300,7 @@ public void testLoadNoBootstrapSegments() throws Exception
         binder -> {
           binder.bindScope(LazySingleton.class, Scopes.SINGLETON);
           final BroadcastDatasourceLoadingSpec broadcastMode = BroadcastDatasourceLoadingSpec.NONE;
-          binder.bind(Key.get(
-                    BroadcastDatasourceLoadingSpec.class,
-                    Names.named(DataSourceTaskIdHolder.BROADCAST_DATASOURCES_TO_LOAD_FOR_TASK)
-                ))
+          binder.bind(Key.get(BroadcastDatasourceLoadingSpec.class, Names.named(DataSourceTaskIdHolder.BROADCAST_DATASOURCES_TO_LOAD_FOR_TASK)))
                 .toInstance(broadcastMode);
         }
     );
@@ -367,12 +360,8 @@ public void testLoadOnlyRequiredBootstrapSegments() throws Exception
         new LifecycleModule(),
         binder -> {
           binder.bindScope(LazySingleton.class, Scopes.SINGLETON);
-          final BroadcastDatasourceLoadingSpec broadcastMode = BroadcastDatasourceLoadingSpec.loadOnly(ImmutableSet.of(
-              "test1"));
-          binder.bind(Key.get(
-                    BroadcastDatasourceLoadingSpec.class,
-                    Names.named(DataSourceTaskIdHolder.BROADCAST_DATASOURCES_TO_LOAD_FOR_TASK)
-                ))
+          final BroadcastDatasourceLoadingSpec broadcastMode = BroadcastDatasourceLoadingSpec.loadOnly(ImmutableSet.of("test1"));
+          binder.bind(Key.get(BroadcastDatasourceLoadingSpec.class, Names.named(DataSourceTaskIdHolder.BROADCAST_DATASOURCES_TO_LOAD_FOR_TASK)))
                 .toInstance(broadcastMode);
         }
     );

From 0ad463a5d689b777b06047edf7c6b497825716ab Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Mon, 31 Mar 2025 17:30:29 -0700
Subject: [PATCH 70/99] validate datasource in CachingClusteredClient as well

---
 .../CachingClusteredClientBenchmark.java      |  2 +
 .../druid/client/CachingClusteredClient.java  | 11 ++++
 ...chingClusteredClientFunctionalityTest.java | 54 +++++++++++++++----
 .../CachingClusteredClientPerfTest.java       |  2 +
 .../client/CachingClusteredClientTest.java    |  2 +
 ...yRunnerBasedOnClusteredClientTestBase.java |  2 +
 6 files changed, 63 insertions(+), 10 deletions(-)

diff --git a/benchmarks/src/test/java/org/apache/druid/benchmark/query/CachingClusteredClientBenchmark.java b/benchmarks/src/test/java/org/apache/druid/benchmark/query/CachingClusteredClientBenchmark.java
index 58361aba7538..9ce5628b3826 100644
--- a/benchmarks/src/test/java/org/apache/druid/benchmark/query/CachingClusteredClientBenchmark.java
+++ b/benchmarks/src/test/java/org/apache/druid/benchmark/query/CachingClusteredClientBenchmark.java
@@ -82,6 +82,7 @@
 import org.apache.druid.query.groupby.GroupByStatsProvider;
 import org.apache.druid.query.groupby.GroupingEngine;
 import org.apache.druid.query.groupby.ResultRow;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.spec.MultipleIntervalSegmentSpec;
 import org.apache.druid.query.spec.QuerySegmentSpec;
 import org.apache.druid.query.timeseries.TimeseriesQuery;
@@ -317,6 +318,7 @@ public boolean useParallelMergePool()
         },
         forkJoinPool,
         QueryStackTests.DEFAULT_NOOP_SCHEDULER,
+        NoopPolicyEnforcer.instance(),
         new NoopServiceEmitter()
     );
   }
diff --git a/server/src/main/java/org/apache/druid/client/CachingClusteredClient.java b/server/src/main/java/org/apache/druid/client/CachingClusteredClient.java
index c2c0b9a546ef..3da77ac65a5f 100644
--- a/server/src/main/java/org/apache/druid/client/CachingClusteredClient.java
+++ b/server/src/main/java/org/apache/druid/client/CachingClusteredClient.java
@@ -43,6 +43,7 @@
 import org.apache.druid.guice.annotations.Merging;
 import org.apache.druid.guice.annotations.Smile;
 import org.apache.druid.guice.http.DruidHttpClientConfig;
+import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.Pair;
 import org.apache.druid.java.util.common.StringUtils;
@@ -72,7 +73,9 @@
 import org.apache.druid.query.aggregation.MetricManipulatorFns;
 import org.apache.druid.query.context.ResponseContext;
 import org.apache.druid.query.filter.DimFilterUtils;
+import org.apache.druid.query.metadata.metadata.SegmentMetadataQuery;
 import org.apache.druid.query.planning.DataSourceAnalysis;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.server.QueryResource;
 import org.apache.druid.server.QueryScheduler;
 import org.apache.druid.server.coordination.DruidServerMetadata;
@@ -125,6 +128,7 @@ public class CachingClusteredClient implements QuerySegmentWalker
   private final BrokerParallelMergeConfig parallelMergeConfig;
   private final ForkJoinPool pool;
   private final QueryScheduler scheduler;
+  private final PolicyEnforcer policyEnforcer;
   private final ServiceEmitter emitter;
 
   @Inject
@@ -139,6 +143,7 @@ public CachingClusteredClient(
       BrokerParallelMergeConfig parallelMergeConfig,
       @Merging ForkJoinPool pool,
       QueryScheduler scheduler,
+      PolicyEnforcer policyEnforcer,
       ServiceEmitter emitter
   )
   {
@@ -152,6 +157,7 @@ public CachingClusteredClient(
     this.parallelMergeConfig = parallelMergeConfig;
     this.pool = pool;
     this.scheduler = scheduler;
+    this.policyEnforcer = policyEnforcer;
     this.emitter = emitter;
 
     if (cacheConfig.isQueryCacheable(Query.GROUP_BY) && (cacheConfig.isUseCache() || cacheConfig.isPopulateCache())) {
@@ -199,6 +205,11 @@ private <T> Sequence<T> run(
       final boolean specificSegments
   )
   {
+    Query<T> query = queryPlus.getQuery();
+    if (!(query instanceof SegmentMetadataQuery) && !policyEnforcer.validate(query.getDataSource())) {
+      throw new ISE("Failed security validation with dataSource [%s]", query.getDataSource());
+    }
+
     final ClusterQueryResult<T> result = new SpecificQueryRunnable<>(queryPlus, responseContext)
         .run(timelineConverter, specificSegments);
     initializeNumRemainingResponsesInResponseContext(queryPlus.getQuery(), responseContext, result.numQueryServers);
diff --git a/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java b/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java
index 27fb1b49cc58..96cbb8b970db 100644
--- a/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java
+++ b/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java
@@ -20,6 +20,7 @@
 package org.apache.druid.client;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Ordering;
@@ -33,6 +34,7 @@
 import org.apache.druid.client.selector.ServerSelector;
 import org.apache.druid.client.selector.TierSelectorStrategy;
 import org.apache.druid.guice.http.DruidHttpClientConfig;
+import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.guava.Sequence;
 import org.apache.druid.query.BrokerParallelMergeConfig;
@@ -40,9 +42,16 @@
 import org.apache.druid.query.Query;
 import org.apache.druid.query.QueryPlus;
 import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.RestrictedDataSource;
 import org.apache.druid.query.TableDataSource;
 import org.apache.druid.query.aggregation.CountAggregatorFactory;
 import org.apache.druid.query.context.ResponseContext;
+import org.apache.druid.query.metadata.metadata.SegmentMetadataQuery;
+import org.apache.druid.query.policy.NoRestrictionPolicy;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
+import org.apache.druid.query.policy.PolicyEnforcer;
+import org.apache.druid.query.policy.RestrictAllTablesPolicyEnforcer;
+import org.apache.druid.query.timeseries.TimeseriesQuery;
 import org.apache.druid.server.QueryStackTests;
 import org.apache.druid.server.coordination.ServerType;
 import org.apache.druid.server.metrics.NoopServiceEmitter;
@@ -73,11 +82,13 @@
 public class CachingClusteredClientFunctionalityTest
 {
   private static final ObjectMapper OBJECT_MAPPER = CachingClusteredClientTestUtils.createObjectMapper();
+  private static final int DEFAULT_MERGE_LIMIT = 10;
 
   private CachingClusteredClient client;
   private VersionedIntervalTimeline<String, ServerSelector> timeline;
   private TimelineServerView serverView;
   private Cache cache;
+  private CachePopulator cachePopulator;
 
   @ClassRule
   public static QueryStackTests.Junit4ConglomerateRule conglomerateRule = new QueryStackTests.Junit4ConglomerateRule();
@@ -88,14 +99,40 @@ public void setUp()
     timeline = new VersionedIntervalTimeline<>(Ordering.natural());
     serverView = EasyMock.createNiceMock(TimelineServerView.class);
     cache = MapCache.create(100000);
-    client = makeClient(
-        new ForegroundCachePopulator(OBJECT_MAPPER, new CachePopulatorStats(), -1)
+    cachePopulator = new ForegroundCachePopulator(OBJECT_MAPPER, new CachePopulatorStats(), -1);
+  }
+
+  @Test
+  public void testPolicyEnforcer()
+  {
+    client = makeClient(new RestrictAllTablesPolicyEnforcer(null));
+    final TimeseriesQuery timeseriesQuery = Druids.newTimeseriesQueryBuilder()
+                                                  .dataSource("test")
+                                                  .intervals("2015-01-02/2015-01-03")
+                                                  .granularity("day")
+                                                  .aggregators(ImmutableList.of(new CountAggregatorFactory("rows")))
+                                                  .context(ImmutableMap.of("uncoveredIntervalsLimit", 3))
+                                                  .build();
+    final SegmentMetadataQuery segmentMetadataQuery = Druids.newSegmentMetadataQueryBuilder()
+                                                            .dataSource("test")
+                                                            .intervals("2015-01-02/2015-01-03")
+                                                            .build();
+    final RestrictedDataSource restricted = RestrictedDataSource.create(
+        TableDataSource.create("test"),
+        NoRestrictionPolicy.instance()
     );
+    // query failed, expecting a restriction on dataSource
+    ISE e = Assert.assertThrows(ISE.class, () -> runQuery(client, timeseriesQuery, ResponseContext.createEmpty()));
+    Assert.assertEquals("Failed security validation with dataSource [test]", e.getMessage());
+    //
+    runQuery(client, segmentMetadataQuery, ResponseContext.createEmpty());
+    runQuery(client, timeseriesQuery.withDataSource(restricted), ResponseContext.createEmpty());
   }
 
   @Test
   public void testUncoveredInterval()
   {
+    client = makeClient();
     addToTimeline(Intervals.of("2015-01-02/2015-01-03"), "1");
     addToTimeline(Intervals.of("2015-01-04/2015-01-05"), "1");
     addToTimeline(Intervals.of("2015-02-04/2015-02-05"), "1");
@@ -217,16 +254,12 @@ public List<QueryableDruidServer> pick(
     ));
   }
 
-  protected CachingClusteredClient makeClient(final CachePopulator cachePopulator)
+  protected CachingClusteredClient makeClient()
   {
-    return makeClient(cachePopulator, cache, 10);
+    return makeClient(NoopPolicyEnforcer.instance());
   }
 
-  protected CachingClusteredClient makeClient(
-      final CachePopulator cachePopulator,
-      final Cache cache,
-      final int mergeLimit
-  )
+  protected CachingClusteredClient makeClient(PolicyEnforcer policyEnforcer)
   {
     return new CachingClusteredClient(
         conglomerateRule.getConglomerate(),
@@ -294,7 +327,7 @@ public boolean isQueryCacheable(Query query)
           @Override
           public int getCacheBulkMergeLimit()
           {
-            return mergeLimit;
+            return DEFAULT_MERGE_LIMIT;
           }
         },
         new DruidHttpClientConfig()
@@ -329,6 +362,7 @@ public int getDefaultMaxQueryParallelism()
         },
         ForkJoinPool.commonPool(),
         QueryStackTests.DEFAULT_NOOP_SCHEDULER,
+        policyEnforcer,
         new NoopServiceEmitter()
     );
   }
diff --git a/server/src/test/java/org/apache/druid/client/CachingClusteredClientPerfTest.java b/server/src/test/java/org/apache/druid/client/CachingClusteredClientPerfTest.java
index d4611710e509..cfcd0e31145b 100644
--- a/server/src/test/java/org/apache/druid/client/CachingClusteredClientPerfTest.java
+++ b/server/src/test/java/org/apache/druid/client/CachingClusteredClientPerfTest.java
@@ -46,6 +46,7 @@
 import org.apache.druid.query.TableDataSource;
 import org.apache.druid.query.context.ResponseContext;
 import org.apache.druid.query.filter.DimFilter;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.spec.MultipleIntervalSegmentSpec;
 import org.apache.druid.query.spec.MultipleSpecificSegmentSpec;
 import org.apache.druid.query.spec.QuerySegmentSpec;
@@ -139,6 +140,7 @@ public void testGetQueryRunnerForSegments_singleIntervalLargeSegments()
         Mockito.mock(BrokerParallelMergeConfig.class),
         ForkJoinPool.commonPool(),
         queryScheduler,
+        NoopPolicyEnforcer.instance(),
         new NoopServiceEmitter()
     );
 
diff --git a/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java b/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
index db9f2ae75d79..6c0c3bbcb7a2 100644
--- a/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
+++ b/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
@@ -93,6 +93,7 @@
 import org.apache.druid.query.groupby.GroupByQuery;
 import org.apache.druid.query.groupby.ResultRow;
 import org.apache.druid.query.ordering.StringComparators;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.search.SearchHit;
 import org.apache.druid.query.search.SearchQuery;
 import org.apache.druid.query.search.SearchQueryConfig;
@@ -2709,6 +2710,7 @@ public int getDefaultMaxQueryParallelism()
             NoQueryLaningStrategy.INSTANCE,
             new ServerConfig()
         ),
+        NoopPolicyEnforcer.instance(),
         new NoopServiceEmitter()
     );
   }
diff --git a/server/src/test/java/org/apache/druid/query/QueryRunnerBasedOnClusteredClientTestBase.java b/server/src/test/java/org/apache/druid/query/QueryRunnerBasedOnClusteredClientTestBase.java
index 76a63442e3ee..3aa16e17f330 100644
--- a/server/src/test/java/org/apache/druid/query/QueryRunnerBasedOnClusteredClientTestBase.java
+++ b/server/src/test/java/org/apache/druid/query/QueryRunnerBasedOnClusteredClientTestBase.java
@@ -43,6 +43,7 @@
 import org.apache.druid.query.aggregation.CountAggregatorFactory;
 import org.apache.druid.query.context.ConcurrentResponseContext;
 import org.apache.druid.query.context.ResponseContext;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.timeseries.TimeseriesResultValue;
 import org.apache.druid.query.topn.TopNQueryConfig;
 import org.apache.druid.segment.QueryableIndex;
@@ -132,6 +133,7 @@ public void setupTestBase()
         QueryStackTests.getParallelMergeConfig(USE_PARALLEL_MERGE_POOL_CONFIGURED),
         ForkJoinPool.commonPool(),
         QueryStackTests.DEFAULT_NOOP_SCHEDULER,
+        NoopPolicyEnforcer.instance(),
         new NoopServiceEmitter()
     );
     servers = new ArrayList<>();

From 06bfcce66c02a03ad4dc78dde4d267f5d31c24f6 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Mon, 31 Mar 2025 17:49:09 -0700
Subject: [PATCH 71/99] fix build failure and update style

---
 .../druid/query/movingaverage/MovingAverageQueryTest.java       | 2 ++
 .../java/org/apache/druid/guice/security/PolicyModuleTest.java  | 1 +
 2 files changed, 3 insertions(+)

diff --git a/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageQueryTest.java b/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageQueryTest.java
index dd5f79eecf5d..57c671b5984c 100644
--- a/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageQueryTest.java
+++ b/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageQueryTest.java
@@ -65,6 +65,7 @@
 import org.apache.druid.query.groupby.GroupByQuery;
 import org.apache.druid.query.groupby.ResultRow;
 import org.apache.druid.query.movingaverage.test.TestConfig;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.timeseries.TimeseriesQuery;
 import org.apache.druid.query.timeseries.TimeseriesResultValue;
 import org.apache.druid.segment.join.MapJoinableFactory;
@@ -365,6 +366,7 @@ public void registerServerRemovedCallback(Executor exec, ServerRemovedCallback c
         new BrokerParallelMergeConfig(),
         ForkJoinPool.commonPool(),
         QueryStackTests.DEFAULT_NOOP_SCHEDULER,
+        NoopPolicyEnforcer.instance(),
         new NoopServiceEmitter()
     );
 
diff --git a/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java b/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
index eb4f702be621..3b1f8d595c71 100644
--- a/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
+++ b/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
@@ -42,6 +42,7 @@ public void testDefaultNoopPolicyEnforcer()
   {
     Properties properties = new Properties();
     PolicyEnforcer policyEnforcer = Guice.createInjector(
+        binder -> binder.bind(Properties.class).toInstance(properties),
         new DruidGuiceExtensions(),
         new ConfigModule(),
         new PolicyModule()

From e610403405e4cd5ff9b43b6225194f656ea31a1f Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Wed, 2 Apr 2025 11:36:57 -0700
Subject: [PATCH 72/99] changes

---
 .../auto/_common/common.runtime.properties    |  5 ++++
 .../cluster/_common/common.runtime.properties |  5 ++++
 .../large/_common/common.runtime.properties   |  4 ++++
 .../medium/_common/common.runtime.properties  |  4 ++++
 .../_common/common.runtime.properties         |  4 ++++
 .../_common/common.runtime.properties         |  4 ++++
 .../small/_common/common.runtime.properties   |  4 ++++
 .../xlarge/_common/common.runtime.properties  |  4 ++++
 .../docker/environment-configs/common         |  1 +
 .../docker/environment-configs/common-ldap    |  1 +
 .../druid/query/policy/PolicyEnforcer.java    | 12 ++++++++--
 .../druid/segment/RestrictedSegment.java      | 11 +++++----
 .../druid/client/CachingClusteredClient.java  |  9 +++----
 .../server/coordination/ServerManager.java    |  8 ++++---
 ...chingClusteredClientFunctionalityTest.java | 24 +++++++++----------
 .../guice/security/PolicyModuleTest.java      |  3 ++-
 .../coordination/ServerManagerTest.java       | 15 ++++--------
 17 files changed, 80 insertions(+), 38 deletions(-)

diff --git a/examples/conf/druid/auto/_common/common.runtime.properties b/examples/conf/druid/auto/_common/common.runtime.properties
index 985a84994d14..13b6cfe8d18f 100644
--- a/examples/conf/druid/auto/_common/common.runtime.properties
+++ b/examples/conf/druid/auto/_common/common.runtime.properties
@@ -151,3 +151,8 @@ druid.lookup.enableLookupSyncOnStartup=false
 # Expression processing config
 #
 druid.expressions.useStrictBooleans=true
+
+#
+# Row security policies
+#
+druid.policy.enforcer.type=none
diff --git a/examples/conf/druid/cluster/_common/common.runtime.properties b/examples/conf/druid/cluster/_common/common.runtime.properties
index 985a84994d14..13b6cfe8d18f 100644
--- a/examples/conf/druid/cluster/_common/common.runtime.properties
+++ b/examples/conf/druid/cluster/_common/common.runtime.properties
@@ -151,3 +151,8 @@ druid.lookup.enableLookupSyncOnStartup=false
 # Expression processing config
 #
 druid.expressions.useStrictBooleans=true
+
+#
+# Row security policies
+#
+druid.policy.enforcer.type=none
diff --git a/examples/conf/druid/single-server/large/_common/common.runtime.properties b/examples/conf/druid/single-server/large/_common/common.runtime.properties
index d27c83ca569e..13b6cfe8d18f 100644
--- a/examples/conf/druid/single-server/large/_common/common.runtime.properties
+++ b/examples/conf/druid/single-server/large/_common/common.runtime.properties
@@ -152,3 +152,7 @@ druid.lookup.enableLookupSyncOnStartup=false
 #
 druid.expressions.useStrictBooleans=true
 
+#
+# Row security policies
+#
+druid.policy.enforcer.type=none
diff --git a/examples/conf/druid/single-server/medium/_common/common.runtime.properties b/examples/conf/druid/single-server/medium/_common/common.runtime.properties
index d27c83ca569e..13b6cfe8d18f 100644
--- a/examples/conf/druid/single-server/medium/_common/common.runtime.properties
+++ b/examples/conf/druid/single-server/medium/_common/common.runtime.properties
@@ -152,3 +152,7 @@ druid.lookup.enableLookupSyncOnStartup=false
 #
 druid.expressions.useStrictBooleans=true
 
+#
+# Row security policies
+#
+druid.policy.enforcer.type=none
diff --git a/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties b/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties
index d27c83ca569e..13b6cfe8d18f 100644
--- a/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties
+++ b/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties
@@ -152,3 +152,7 @@ druid.lookup.enableLookupSyncOnStartup=false
 #
 druid.expressions.useStrictBooleans=true
 
+#
+# Row security policies
+#
+druid.policy.enforcer.type=none
diff --git a/examples/conf/druid/single-server/nano-quickstart/_common/common.runtime.properties b/examples/conf/druid/single-server/nano-quickstart/_common/common.runtime.properties
index d27c83ca569e..13b6cfe8d18f 100644
--- a/examples/conf/druid/single-server/nano-quickstart/_common/common.runtime.properties
+++ b/examples/conf/druid/single-server/nano-quickstart/_common/common.runtime.properties
@@ -152,3 +152,7 @@ druid.lookup.enableLookupSyncOnStartup=false
 #
 druid.expressions.useStrictBooleans=true
 
+#
+# Row security policies
+#
+druid.policy.enforcer.type=none
diff --git a/examples/conf/druid/single-server/small/_common/common.runtime.properties b/examples/conf/druid/single-server/small/_common/common.runtime.properties
index d27c83ca569e..13b6cfe8d18f 100644
--- a/examples/conf/druid/single-server/small/_common/common.runtime.properties
+++ b/examples/conf/druid/single-server/small/_common/common.runtime.properties
@@ -152,3 +152,7 @@ druid.lookup.enableLookupSyncOnStartup=false
 #
 druid.expressions.useStrictBooleans=true
 
+#
+# Row security policies
+#
+druid.policy.enforcer.type=none
diff --git a/examples/conf/druid/single-server/xlarge/_common/common.runtime.properties b/examples/conf/druid/single-server/xlarge/_common/common.runtime.properties
index d27c83ca569e..13b6cfe8d18f 100644
--- a/examples/conf/druid/single-server/xlarge/_common/common.runtime.properties
+++ b/examples/conf/druid/single-server/xlarge/_common/common.runtime.properties
@@ -152,3 +152,7 @@ druid.lookup.enableLookupSyncOnStartup=false
 #
 druid.expressions.useStrictBooleans=true
 
+#
+# Row security policies
+#
+druid.policy.enforcer.type=none
diff --git a/integration-tests/docker/environment-configs/common b/integration-tests/docker/environment-configs/common
index e99ee2acd43c..3d35ff022211 100644
--- a/integration-tests/docker/environment-configs/common
+++ b/integration-tests/docker/environment-configs/common
@@ -39,6 +39,7 @@ druid_auth_authenticatorChain=["basic"]
 druid_auth_authorizer_basic_type=basic
 druid_auth_authorizers=["basic"]
 druid_auth_authorizeQueryContextParams=true
+druid_policy_enforcer_type=none
 druid_client_https_certAlias=druid
 druid_client_https_keyManagerPassword=druid123
 druid_client_https_keyStorePassword=druid123
diff --git a/integration-tests/docker/environment-configs/common-ldap b/integration-tests/docker/environment-configs/common-ldap
index fae9b18c341a..9a022b19c79b 100644
--- a/integration-tests/docker/environment-configs/common-ldap
+++ b/integration-tests/docker/environment-configs/common-ldap
@@ -49,6 +49,7 @@ druid_auth_authorizer_ldapauth_initialAdminRole=admin
 druid_auth_authorizer_ldapauth_roleProvider_type=ldap
 druid_auth_authorizers=["ldapauth"]
 druid_auth_authorizeQueryContextParams=true
+druid_policy_enforcer_type=none
 druid_client_https_certAlias=druid
 druid_client_https_keyManagerPassword=druid123
 druid_client_https_keyStorePassword=druid123
diff --git a/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java b/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
index d48942e373ec..4881632297cd 100644
--- a/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
+++ b/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
@@ -26,8 +26,13 @@
 
 /**
  * A mechanism for enforcing policies on data sources in Druid queries.
+ * <p>
+ * Note: The {@code PolicyEnforcer} is intended to serve as a sanity checker and not as a primary authorization mechanism.
+ * It should not be used to implement security rules. Instead, it acts as a last line of defense to verify that
+ * security policies have been implemented correctly and to prevent incorrect policy usage.
+ * </p>
  */
-@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type", defaultImpl = NoopPolicyEnforcer.class)
+@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type")
 @JsonSubTypes({
     @JsonSubTypes.Type(value = NoopPolicyEnforcer.class, name = "none"),
     @JsonSubTypes.Type(value = RestrictAllTablesPolicyEnforcer.class, name = "restrictAllTables"),
@@ -37,7 +42,10 @@ public interface PolicyEnforcer
 {
 
   /**
-   * Validate a data source against the policy enforcer.
+   * Validate a {@link DataSource} against the policy enforcer. The data source must be authorized and include an
+   * attached {@link Policy}, if applicable. The enforcer will validate it before executing any queries on the data
+   * source.
+   *
    * @param ds data source to validate
    * @return true if the data source is valid according to the policy enforcer, false otherwise
    */
diff --git a/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java b/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java
index 2902afe2949c..c4a7cb4828e8 100644
--- a/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java
+++ b/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java
@@ -19,7 +19,6 @@
 
 package org.apache.druid.segment;
 
-import com.google.common.annotations.VisibleForTesting;
 import org.apache.druid.query.policy.NoRestrictionPolicy;
 import org.apache.druid.query.policy.Policy;
 import org.apache.druid.timeline.SegmentId;
@@ -43,11 +42,13 @@
  */
 public class RestrictedSegment implements SegmentReference
 {
-  @VisibleForTesting
-  public final SegmentReference delegate;
-  final Policy policy;
+  protected final SegmentReference delegate;
+  protected final Policy policy;
 
-  public RestrictedSegment(SegmentReference delegate, Policy policy)
+  public RestrictedSegment(
+      SegmentReference delegate,
+      Policy policy
+  )
   {
     this.delegate = delegate;
     this.policy = policy;
diff --git a/server/src/main/java/org/apache/druid/client/CachingClusteredClient.java b/server/src/main/java/org/apache/druid/client/CachingClusteredClient.java
index 3da77ac65a5f..f46384679a29 100644
--- a/server/src/main/java/org/apache/druid/client/CachingClusteredClient.java
+++ b/server/src/main/java/org/apache/druid/client/CachingClusteredClient.java
@@ -39,11 +39,11 @@
 import org.apache.druid.client.cache.CacheConfig;
 import org.apache.druid.client.cache.CachePopulator;
 import org.apache.druid.client.selector.ServerSelector;
+import org.apache.druid.error.DruidException;
 import org.apache.druid.guice.annotations.Client;
 import org.apache.druid.guice.annotations.Merging;
 import org.apache.druid.guice.annotations.Smile;
 import org.apache.druid.guice.http.DruidHttpClientConfig;
-import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.Pair;
 import org.apache.druid.java.util.common.StringUtils;
@@ -73,7 +73,6 @@
 import org.apache.druid.query.aggregation.MetricManipulatorFns;
 import org.apache.druid.query.context.ResponseContext;
 import org.apache.druid.query.filter.DimFilterUtils;
-import org.apache.druid.query.metadata.metadata.SegmentMetadataQuery;
 import org.apache.druid.query.planning.DataSourceAnalysis;
 import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.server.QueryResource;
@@ -206,8 +205,10 @@ private <T> Sequence<T> run(
   )
   {
     Query<T> query = queryPlus.getQuery();
-    if (!(query instanceof SegmentMetadataQuery) && !policyEnforcer.validate(query.getDataSource())) {
-      throw new ISE("Failed security validation with dataSource [%s]", query.getDataSource());
+    if (!query.getDataSource().validate(policyEnforcer)) {
+      throw DruidException.forPersona(DruidException.Persona.OPERATOR)
+                          .ofCategory(DruidException.Category.FORBIDDEN)
+                          .build("Failed security validation with dataSource [%s]", query.getDataSource());
     }
 
     final ClusterQueryResult<T> result = new SpecificQueryRunnable<>(queryPlus, responseContext)
diff --git a/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java b/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
index e93f5268834b..28eb6f012a9f 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
@@ -26,6 +26,7 @@
 import org.apache.druid.client.cache.Cache;
 import org.apache.druid.client.cache.CacheConfig;
 import org.apache.druid.client.cache.CachePopulator;
+import org.apache.druid.error.DruidException;
 import org.apache.druid.guice.annotations.Smile;
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.StringUtils;
@@ -53,7 +54,6 @@
 import org.apache.druid.query.ReferenceCountingSegmentQueryRunner;
 import org.apache.druid.query.ReportTimelineMissingSegmentQueryRunner;
 import org.apache.druid.query.SegmentDescriptor;
-import org.apache.druid.query.metadata.metadata.SegmentMetadataQuery;
 import org.apache.druid.query.planning.DataSourceAnalysis;
 import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.query.spec.SpecificSegmentQueryRunner;
@@ -195,8 +195,10 @@ public <T> QueryRunner<T> getQueryRunnerForSegments(Query<T> theQuery, Iterable<
       throw new ISE("Cannot handle subquery: %s", dataSourceFromQuery);
     }
 
-    if (!(theQuery instanceof SegmentMetadataQuery) && !policyEnforcer.validate(dataSourceFromQuery)) {
-      throw new ISE("Failed security validation with dataSource [%s]", dataSourceFromQuery);
+    if (!dataSourceFromQuery.validate(policyEnforcer)) {
+      throw DruidException.forPersona(DruidException.Persona.OPERATOR)
+                          .ofCategory(DruidException.Category.FORBIDDEN)
+                          .build("Failed security validation with dataSource [%s]", dataSourceFromQuery);
     }
 
     if (maybeTimeline.isPresent()) {
diff --git a/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java b/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java
index 96cbb8b970db..e3a6674283fc 100644
--- a/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java
+++ b/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java
@@ -33,8 +33,8 @@
 import org.apache.druid.client.cache.MapCache;
 import org.apache.druid.client.selector.ServerSelector;
 import org.apache.druid.client.selector.TierSelectorStrategy;
+import org.apache.druid.error.DruidException;
 import org.apache.druid.guice.http.DruidHttpClientConfig;
-import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.guava.Sequence;
 import org.apache.druid.query.BrokerParallelMergeConfig;
@@ -46,7 +46,6 @@
 import org.apache.druid.query.TableDataSource;
 import org.apache.druid.query.aggregation.CountAggregatorFactory;
 import org.apache.druid.query.context.ResponseContext;
-import org.apache.druid.query.metadata.metadata.SegmentMetadataQuery;
 import org.apache.druid.query.policy.NoRestrictionPolicy;
 import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.policy.PolicyEnforcer;
@@ -113,20 +112,21 @@ public void testPolicyEnforcer()
                                                   .aggregators(ImmutableList.of(new CountAggregatorFactory("rows")))
                                                   .context(ImmutableMap.of("uncoveredIntervalsLimit", 3))
                                                   .build();
-    final SegmentMetadataQuery segmentMetadataQuery = Druids.newSegmentMetadataQueryBuilder()
-                                                            .dataSource("test")
-                                                            .intervals("2015-01-02/2015-01-03")
-                                                            .build();
+    // query failed, expecting a restriction on dataSource
+    DruidException e = Assert.assertThrows(
+        DruidException.class,
+        () -> runQuery(client, timeseriesQuery, ResponseContext.createEmpty())
+    );
+    Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
+    Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
+    Assert.assertEquals("Failed security validation with dataSource [test]", e.getMessage());
+
     final RestrictedDataSource restricted = RestrictedDataSource.create(
         TableDataSource.create("test"),
         NoRestrictionPolicy.instance()
     );
-    // query failed, expecting a restriction on dataSource
-    ISE e = Assert.assertThrows(ISE.class, () -> runQuery(client, timeseriesQuery, ResponseContext.createEmpty()));
-    Assert.assertEquals("Failed security validation with dataSource [test]", e.getMessage());
-    //
-    runQuery(client, segmentMetadataQuery, ResponseContext.createEmpty());
-    runQuery(client, timeseriesQuery.withDataSource(restricted), ResponseContext.createEmpty());
+    final TimeseriesQuery timeseriesQueryWithRestriction = (TimeseriesQuery) timeseriesQuery.withDataSource(restricted);
+    runQuery(client, timeseriesQueryWithRestriction, ResponseContext.createEmpty());
   }
 
   @Test
diff --git a/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java b/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
index 3b1f8d595c71..ad3f64e0cbd1 100644
--- a/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
+++ b/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
@@ -38,9 +38,10 @@
 public class PolicyModuleTest
 {
   @Test
-  public void testDefaultNoopPolicyEnforcer()
+  public void testConfigNoopPolicyEnforcer()
   {
     Properties properties = new Properties();
+    properties.setProperty("druid.policy.enforcer.type", "none");
     PolicyEnforcer policyEnforcer = Guice.createInjector(
         binder -> binder.bind(Properties.class).toInstance(properties),
         new DruidGuiceExtensions(),
diff --git a/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java b/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
index 48691f16d1bb..26874e555aac 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
@@ -40,7 +40,6 @@
 import org.apache.druid.guice.annotations.Smile;
 import org.apache.druid.jackson.DefaultObjectMapper;
 import org.apache.druid.java.util.common.IAE;
-import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.Pair;
 import org.apache.druid.java.util.common.concurrent.Execs;
@@ -77,7 +76,6 @@
 import org.apache.druid.query.aggregation.MetricManipulationFn;
 import org.apache.druid.query.context.DefaultResponseContext;
 import org.apache.druid.query.context.ResponseContext;
-import org.apache.druid.query.metadata.metadata.SegmentMetadataQuery;
 import org.apache.druid.query.policy.NoRestrictionPolicy;
 import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.policy.PolicyEnforcer;
@@ -607,8 +605,6 @@ public void testGetQueryRunnerForSegments_restricted() throws Exception
   {
     conglomerate = DefaultQueryRunnerFactoryConglomerate.buildFromQueryRunnerFactories(ImmutableMap.of(
         SearchQuery.class,
-        factory,
-        SegmentMetadataQuery.class,
         factory
     ));
     policyEnforcer = new RestrictAllTablesPolicyEnforcer(ImmutableList.of("NoRestrictionPolicy"));
@@ -619,18 +615,15 @@ public void testGetQueryRunnerForSegments_restricted() throws Exception
         TableDataSource.create("test"),
         NoRestrictionPolicy.instance()
     ), interval, Granularities.ALL);
-    SegmentMetadataQuery segmentMetadataQuery = Druids.newSegmentMetadataQueryBuilder()
-                                                      .dataSource("test")
-                                                      .intervals(interval.toString())
-                                                      .build();
 
-    ISE e = Assert.assertThrows(
-        ISE.class,
+    DruidException e = Assert.assertThrows(
+        DruidException.class,
         () -> serverManager.getQueryRunnerForIntervals(query, ImmutableList.of(interval))
     );
+    Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
+    Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
     Assert.assertEquals("Failed security validation with dataSource [test]", e.getMessage());
     Assert.assertNotNull(serverManager.getQueryRunnerForIntervals(queryOnRestricted, ImmutableList.of(interval)));
-    Assert.assertNotNull(serverManager.getQueryRunnerForIntervals(segmentMetadataQuery, ImmutableList.of(interval)));
   }
 
   private void waitForTestVerificationAndCleanup(Future future)

From fbccd532b794d5d8a9bec7f4abf23a155036acbd Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Wed, 2 Apr 2025 12:34:46 -0700
Subject: [PATCH 73/99] add inlineds test

---
 .../test/java/org/apache/druid/query/DataSourceTest.java | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/processing/src/test/java/org/apache/druid/query/DataSourceTest.java b/processing/src/test/java/org/apache/druid/query/DataSourceTest.java
index dd1ec49825ed..d5bd2314093d 100644
--- a/processing/src/test/java/org/apache/druid/query/DataSourceTest.java
+++ b/processing/src/test/java/org/apache/druid/query/DataSourceTest.java
@@ -35,6 +35,7 @@
 import org.apache.druid.query.policy.RestrictAllTablesPolicyEnforcer;
 import org.apache.druid.query.policy.RowFilterPolicy;
 import org.apache.druid.segment.TestHelper;
+import org.apache.druid.segment.column.RowSignature;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -225,6 +226,14 @@ public void testWithPolicies_onRestrictedDataSource_alwaysThrows()
     Assert.assertEquals("Missing policy check result for table [table1]", e3.getMessage());
   }
 
+  @Test
+  public void testValidate_onInlineDataSource()
+  {
+    InlineDataSource inlineDataSource = InlineDataSource.fromIterable(ImmutableList.of(), RowSignature.empty());
+    Assert.assertTrue(inlineDataSource.validate(NoopPolicyEnforcer.instance()));
+    Assert.assertTrue(inlineDataSource.validate(new RestrictAllTablesPolicyEnforcer(null)));
+  }
+
   @Test
   public void testValidate_onRestrictedDataSource()
   {

From ef89d308114b96e82dd5ca0cc3e6926613afa20a Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Wed, 2 Apr 2025 17:48:08 -0700
Subject: [PATCH 74/99] add sanity check on segment

---
 .../msq/dart/worker/DartFrameContext.java     |  7 +++++
 .../msq/indexing/IndexerFrameContext.java     |  7 +++++
 .../apache/druid/msq/kernel/FrameContext.java |  3 ++
 .../msq/querykit/BaseLeafFrameProcessor.java  | 21 ++++++++++++--
 .../GroupByPreShuffleFrameProcessor.java      |  3 ++
 ...roupByPreShuffleFrameProcessorFactory.java |  1 +
 .../scan/ScanQueryFrameProcessor.java         |  3 ++
 .../scan/ScanQueryFrameProcessorFactory.java  |  1 +
 .../scan/ScanQueryFrameProcessorTest.java     |  3 ++
 .../druid/msq/test/MSQTestWorkerContext.java  |  7 +++++
 .../org/apache/druid/query/DataSource.java    |  3 ++
 .../ReferenceCountingSegmentQueryRunner.java  | 16 ++++++++++-
 .../druid/query/RestrictedDataSource.java     |  2 +-
 .../apache/druid/query/TableDataSource.java   |  2 +-
 .../query/policy/NoopPolicyEnforcer.java      |  9 +++++-
 .../druid/query/policy/PolicyEnforcer.java    | 22 ++++++++++++---
 .../RestrictAllTablesPolicyEnforcer.java      | 14 ++++++++--
 .../druid/segment/RestrictedSegment.java      |  7 +++++
 .../org/apache/druid/segment/Segment.java     | 12 +++++++-
 .../segment/WrappedSegmentReference.java      |  7 +++++
 .../druid/segment/join/HashJoinSegment.java   |  7 +++++
 .../query/policy/NoopPolicyEnforcerTest.java  | 17 +++++++++--
 .../RestrictAllTablesPolicyEnforcerTest.java  | 28 ++++++++++++++++---
 .../druid/segment}/TestSegmentUtils.java      | 15 +++-------
 .../server/coordination/ServerManager.java    |  2 +-
 .../loading/SegmentLocalCacheManagerTest.java |  2 +-
 .../druid/server/SegmentManagerTest.java      |  1 +
 .../server/TestClusterQuerySegmentWalker.java |  4 ++-
 .../SegmentBootstrapperCacheTest.java         |  2 +-
 .../coordination/SegmentBootstrapperTest.java |  2 +-
 .../SegmentLoadDropHandlerTest.java           |  2 +-
 .../coordination/ServerManagerTest.java       |  4 +--
 .../test/utils/TestSegmentCacheManager.java   |  2 +-
 33 files changed, 199 insertions(+), 39 deletions(-)
 rename {server/src/test/java/org/apache/druid/server => processing/src/test/java/org/apache/druid/segment}/TestSegmentUtils.java (94%)

diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartFrameContext.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartFrameContext.java
index ff7d9fdc4e9f..09d69bc3e679 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartFrameContext.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartFrameContext.java
@@ -32,6 +32,7 @@
 import org.apache.druid.msq.kernel.StageId;
 import org.apache.druid.msq.querykit.DataSegmentProvider;
 import org.apache.druid.query.groupby.GroupingEngine;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.IndexIO;
 import org.apache.druid.segment.IndexMergerV9;
 import org.apache.druid.segment.SegmentWrangler;
@@ -78,6 +79,12 @@ public DartFrameContext(
     this.storageParameters = storageParameters;
   }
 
+  @Override
+  public PolicyEnforcer policyEnforcer()
+  {
+    return workerContext.injector().getInstance(PolicyEnforcer.class);
+  }
+
   @Override
   public SegmentWrangler segmentWrangler()
   {
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/indexing/IndexerFrameContext.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/indexing/IndexerFrameContext.java
index e8f3739facb4..293034602584 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/indexing/IndexerFrameContext.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/indexing/IndexerFrameContext.java
@@ -31,6 +31,7 @@
 import org.apache.druid.msq.kernel.StageId;
 import org.apache.druid.msq.querykit.DataSegmentProvider;
 import org.apache.druid.query.groupby.GroupingEngine;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.IndexIO;
 import org.apache.druid.segment.IndexMergerV9;
 import org.apache.druid.segment.SegmentWrangler;
@@ -73,6 +74,12 @@ public IndexerFrameContext(
     this.dataServerQueryHandlerFactory = dataServerQueryHandlerFactory;
   }
 
+  @Override
+  public PolicyEnforcer policyEnforcer()
+  {
+    return context.injector().getInstance(PolicyEnforcer.class);
+  }
+
   @Override
   public SegmentWrangler segmentWrangler()
   {
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/kernel/FrameContext.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/kernel/FrameContext.java
index 1b80f72f86f5..e762d1f78407 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/kernel/FrameContext.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/kernel/FrameContext.java
@@ -27,6 +27,7 @@
 import org.apache.druid.msq.exec.WorkerStorageParameters;
 import org.apache.druid.msq.querykit.DataSegmentProvider;
 import org.apache.druid.query.groupby.GroupingEngine;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.IndexIO;
 import org.apache.druid.segment.IndexMergerV9;
 import org.apache.druid.segment.SegmentWrangler;
@@ -44,6 +45,8 @@
  */
 public interface FrameContext extends Closeable
 {
+  PolicyEnforcer policyEnforcer();
+
   SegmentWrangler segmentWrangler();
 
   GroupingEngine groupingEngine();
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessor.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessor.java
index b3349a9be705..98e4dd0dfea2 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessor.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessor.java
@@ -21,6 +21,7 @@
 
 import it.unimi.dsi.fastutil.ints.IntSet;
 import org.apache.druid.collections.ResourceHolder;
+import org.apache.druid.error.DruidException;
 import org.apache.druid.frame.channel.ReadableFrameChannel;
 import org.apache.druid.frame.channel.WritableFrameChannel;
 import org.apache.druid.frame.processor.FrameProcessor;
@@ -33,6 +34,7 @@
 import org.apache.druid.msq.input.ReadableInput;
 import org.apache.druid.msq.input.table.SegmentWithDescriptor;
 import org.apache.druid.msq.input.table.SegmentsInputSlice;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.ReferenceCountingSegment;
 import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.SegmentReference;
@@ -45,18 +47,21 @@
 public abstract class BaseLeafFrameProcessor implements FrameProcessor<Object>
 {
   private final ReadableInput baseInput;
+  private final PolicyEnforcer policyEnforcer;
   private final ResourceHolder<WritableFrameChannel> outputChannelHolder;
   private final ResourceHolder<FrameWriterFactory> frameWriterFactoryHolder;
   private final Function<SegmentReference, SegmentReference> segmentMapFn;
 
   protected BaseLeafFrameProcessor(
       final ReadableInput baseInput,
+      final PolicyEnforcer policyEnforcer,
       final Function<SegmentReference, SegmentReference> segmentMapFn,
       final ResourceHolder<WritableFrameChannel> outputChannelHolder,
       final ResourceHolder<FrameWriterFactory> frameWriterFactoryHolder
   )
   {
     this.baseInput = baseInput;
+    this.policyEnforcer = policyEnforcer;
     this.outputChannelHolder = outputChannelHolder;
     this.frameWriterFactoryHolder = frameWriterFactoryHolder;
     this.segmentMapFn = segmentMapFn;
@@ -119,7 +124,8 @@ protected FrameWriterFactory getFrameWriterFactory()
    * Runs the leaf processor using the results from a data server as the input. The query and data server details are
    * described by {@link DataServerQueryHandler}.
    */
-  protected abstract ReturnOrAwait<SegmentsInputSlice> runWithDataServerQuery(DataServerQueryHandler dataServerQueryHandler) throws IOException;
+  protected abstract ReturnOrAwait<SegmentsInputSlice> runWithDataServerQuery(DataServerQueryHandler dataServerQueryHandler)
+      throws IOException;
 
   protected abstract ReturnOrAwait<Unit> runWithInputChannel(
       ReadableFrameChannel inputChannel,
@@ -132,6 +138,17 @@ protected abstract ReturnOrAwait<Unit> runWithInputChannel(
    */
   protected SegmentReference mapSegment(final Segment segment)
   {
-    return segmentMapFn.apply(ReferenceCountingSegment.wrapRootGenerationSegment(segment));
+    SegmentReference mappedSegment = segmentMapFn.apply(ReferenceCountingSegment.wrapRootGenerationSegment(segment));
+    if (mappedSegment.validate(policyEnforcer)) {
+      return mappedSegment;
+    } else {
+      throw DruidException.forPersona(DruidException.Persona.OPERATOR)
+                          .ofCategory(DruidException.Category.FORBIDDEN)
+                          .build(
+                              "Failed security validation with segment [%s] type [%s]",
+                              segment.getId(),
+                              segment.getClass()
+                          );
+    }
   }
 }
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/groupby/GroupByPreShuffleFrameProcessor.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/groupby/GroupByPreShuffleFrameProcessor.java
index ad456a45f5b1..d636385a84f2 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/groupby/GroupByPreShuffleFrameProcessor.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/groupby/GroupByPreShuffleFrameProcessor.java
@@ -51,6 +51,7 @@
 import org.apache.druid.query.groupby.GroupingEngine;
 import org.apache.druid.query.groupby.ResultRow;
 import org.apache.druid.query.groupby.epinephelinae.RowBasedGrouperHelper;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.query.spec.MultipleIntervalSegmentSpec;
 import org.apache.druid.query.spec.SpecificSegmentSpec;
 import org.apache.druid.segment.ColumnSelectorFactory;
@@ -88,6 +89,7 @@ public GroupByPreShuffleFrameProcessor(
       final GroupByQuery query,
       final GroupingEngine groupingEngine,
       final NonBlockingPool<ByteBuffer> bufferPool,
+      final PolicyEnforcer policyEnforcer,
       final ReadableInput baseInput,
       final Function<SegmentReference, SegmentReference> segmentMapFn,
       final ResourceHolder<WritableFrameChannel> outputChannelHolder,
@@ -96,6 +98,7 @@ public GroupByPreShuffleFrameProcessor(
   {
     super(
         baseInput,
+        policyEnforcer,
         segmentMapFn,
         outputChannelHolder,
         frameWriterFactoryHolder
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/groupby/GroupByPreShuffleFrameProcessorFactory.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/groupby/GroupByPreShuffleFrameProcessorFactory.java
index 5ae163c1fd0d..38155b4d6232 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/groupby/GroupByPreShuffleFrameProcessorFactory.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/groupby/GroupByPreShuffleFrameProcessorFactory.java
@@ -66,6 +66,7 @@ protected FrameProcessor<Object> makeProcessor(
         query,
         frameContext.groupingEngine(),
         frameContext.processingBuffers().getBufferPool(),
+        frameContext.policyEnforcer(),
         baseInput,
         segmentMapFn,
         outputChannelHolder,
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessor.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessor.java
index 1be191bddbe6..20a5c67101d1 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessor.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessor.java
@@ -62,6 +62,7 @@
 import org.apache.druid.query.Druids;
 import org.apache.druid.query.IterableRowsCursorHelper;
 import org.apache.druid.query.Order;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.query.scan.ScanQuery;
 import org.apache.druid.query.scan.ScanQueryEngine;
 import org.apache.druid.query.scan.ScanResultValue;
@@ -116,6 +117,7 @@ public ScanQueryFrameProcessor(
       final ScanQuery query,
       @Nullable final AtomicLong runningCountForLimit,
       final ObjectMapper jsonMapper,
+      final PolicyEnforcer policyEnforcer,
       final ReadableInput baseInput,
       final Function<SegmentReference, SegmentReference> segmentMapFn,
       final ResourceHolder<WritableFrameChannel> outputChannelHolder,
@@ -124,6 +126,7 @@ public ScanQueryFrameProcessor(
   {
     super(
         baseInput,
+        policyEnforcer,
         segmentMapFn,
         outputChannelHolder,
         frameWriterFactoryHolder
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorFactory.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorFactory.java
index 1636e1177406..1d73f3c08e87 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorFactory.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorFactory.java
@@ -78,6 +78,7 @@ protected FrameProcessor<Object> makeProcessor(
         query,
         runningCountForLimit,
         frameContext.jsonMapper(),
+        frameContext.policyEnforcer(),
         baseInput,
         segmentMapFn,
         outputChannelHolder,
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorTest.java
index 21e3707f00fd..bcfe76af0052 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorTest.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorTest.java
@@ -48,6 +48,7 @@
 import org.apache.druid.msq.querykit.FrameProcessorTestBase;
 import org.apache.druid.msq.test.LimitedFrameWriterFactory;
 import org.apache.druid.query.Druids;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.scan.ScanQuery;
 import org.apache.druid.query.spec.MultipleIntervalSegmentSpec;
 import org.apache.druid.segment.CompleteSegment;
@@ -113,6 +114,7 @@ public void test_runWithSegments() throws Exception
         query,
         null,
         new DefaultObjectMapper(),
+        NoopPolicyEnforcer.instance(),
         ReadableInput.segment(
             new SegmentWithDescriptor(
                 () -> new StupidResourceHolder<>(new CompleteSegment(null, new QueryableIndexSegment(queryableIndex, SegmentId.dummy("test")))),
@@ -212,6 +214,7 @@ public void test_runWithInputChannel() throws Exception
         query,
         null,
         new DefaultObjectMapper(),
+        NoopPolicyEnforcer.instance(),
         ReadableInput.channel(inputChannel.readable(), FrameReader.create(signature), stagePartition),
         Function.identity(),
         new ResourceHolder<>()
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestWorkerContext.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestWorkerContext.java
index f4b7171a6126..2ee604beb0cb 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestWorkerContext.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestWorkerContext.java
@@ -38,6 +38,7 @@
 import org.apache.druid.msq.kernel.WorkOrder;
 import org.apache.druid.msq.querykit.DataSegmentProvider;
 import org.apache.druid.query.groupby.GroupingEngine;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.IndexIO;
 import org.apache.druid.segment.IndexMergerV9;
 import org.apache.druid.segment.SegmentWrangler;
@@ -175,6 +176,12 @@ public FrameContextImpl(File tempDir)
       this.tempDir = tempDir;
     }
 
+    @Override
+    public PolicyEnforcer policyEnforcer()
+    {
+      return injector.getInstance(PolicyEnforcer.class);
+    }
+
     @Override
     public SegmentWrangler segmentWrangler()
     {
diff --git a/processing/src/main/java/org/apache/druid/query/DataSource.java b/processing/src/main/java/org/apache/druid/query/DataSource.java
index 41d6bf710b3b..7ad2f5b4361a 100644
--- a/processing/src/main/java/org/apache/druid/query/DataSource.java
+++ b/processing/src/main/java/org/apache/druid/query/DataSource.java
@@ -26,6 +26,7 @@
 import org.apache.druid.query.policy.Policy;
 import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.SegmentReference;
+
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -143,6 +144,8 @@ default DataSource withPolicies(Map<String, Optional<Policy>> policyMap)
 
   /**
    * Returns true if the datasource complies with the policy restrictions on tables.
+   * <p>
+   * This should be called right before the data source is about to be processed by the query stack.
    */
   default boolean validate(PolicyEnforcer policyEnforcer)
   {
diff --git a/processing/src/main/java/org/apache/druid/query/ReferenceCountingSegmentQueryRunner.java b/processing/src/main/java/org/apache/druid/query/ReferenceCountingSegmentQueryRunner.java
index a92bbd6421b7..a88de6e4d046 100644
--- a/processing/src/main/java/org/apache/druid/query/ReferenceCountingSegmentQueryRunner.java
+++ b/processing/src/main/java/org/apache/druid/query/ReferenceCountingSegmentQueryRunner.java
@@ -19,9 +19,11 @@
 
 package org.apache.druid.query;
 
+import org.apache.druid.error.DruidException;
 import org.apache.druid.java.util.common.guava.Sequence;
 import org.apache.druid.java.util.common.guava.Sequences;
 import org.apache.druid.query.context.ResponseContext;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.SegmentReference;
 
 public class ReferenceCountingSegmentQueryRunner<T> implements QueryRunner<T>
@@ -29,21 +31,33 @@ public class ReferenceCountingSegmentQueryRunner<T> implements QueryRunner<T>
   private final QueryRunnerFactory<T, Query<T>> factory;
   private final SegmentReference segment;
   private final SegmentDescriptor descriptor;
+  private final PolicyEnforcer policyEnforcer;
 
   public ReferenceCountingSegmentQueryRunner(
       QueryRunnerFactory<T, Query<T>> factory,
       SegmentReference segment,
-      SegmentDescriptor descriptor
+      SegmentDescriptor descriptor,
+      PolicyEnforcer policyEnforcer
   )
   {
     this.factory = factory;
     this.segment = segment;
     this.descriptor = descriptor;
+    this.policyEnforcer = policyEnforcer;
   }
 
   @Override
   public Sequence<T> run(final QueryPlus<T> queryPlus, ResponseContext responseContext)
   {
+    if (!segment.validate(policyEnforcer)) {
+      throw DruidException.forPersona(DruidException.Persona.OPERATOR)
+                          .ofCategory(DruidException.Category.FORBIDDEN)
+                          .build(
+                              "Failed security validation with segment [%s] and type [%s]",
+                              segment.getId(),
+                              segment.getClass()
+                          );
+    }
     return segment.acquireReferences().map(closeable -> {
       try {
         final Sequence<T> baseSequence = factory.createRunner(segment).run(queryPlus, responseContext);
diff --git a/processing/src/main/java/org/apache/druid/query/RestrictedDataSource.java b/processing/src/main/java/org/apache/druid/query/RestrictedDataSource.java
index 241104626cb9..013fe100b0e6 100644
--- a/processing/src/main/java/org/apache/druid/query/RestrictedDataSource.java
+++ b/processing/src/main/java/org/apache/druid/query/RestrictedDataSource.java
@@ -171,7 +171,7 @@ public DataSource withPolicies(Map<String, Optional<Policy>> policyMap)
   @Override
   public boolean validate(PolicyEnforcer policyEnforcer)
   {
-    return policyEnforcer.validate(this);
+    return policyEnforcer.validate(this, policy);
   }
 
   @Override
diff --git a/processing/src/main/java/org/apache/druid/query/TableDataSource.java b/processing/src/main/java/org/apache/druid/query/TableDataSource.java
index 61fc48bdc376..01a45e0b368f 100644
--- a/processing/src/main/java/org/apache/druid/query/TableDataSource.java
+++ b/processing/src/main/java/org/apache/druid/query/TableDataSource.java
@@ -127,7 +127,7 @@ public DataSource withPolicies(Map<String, Optional<Policy>> policyMap)
   public boolean validate(PolicyEnforcer policyEnforcer)
   {
     // If it reaches here, this table is not wrapped with a RestrictedDataSource (which should overwrite this method).
-    return policyEnforcer.validate(this);
+    return policyEnforcer.validate(this, null);
   }
 
   @Override
diff --git a/processing/src/main/java/org/apache/druid/query/policy/NoopPolicyEnforcer.java b/processing/src/main/java/org/apache/druid/query/policy/NoopPolicyEnforcer.java
index f82223fc7cfc..38d87fec4440 100644
--- a/processing/src/main/java/org/apache/druid/query/policy/NoopPolicyEnforcer.java
+++ b/processing/src/main/java/org/apache/druid/query/policy/NoopPolicyEnforcer.java
@@ -21,6 +21,7 @@
 
 import com.fasterxml.jackson.annotation.JsonCreator;
 import org.apache.druid.query.DataSource;
+import org.apache.druid.segment.Segment;
 
 /**
  * Allows all data sources (no restrictions).
@@ -32,7 +33,13 @@ public class NoopPolicyEnforcer implements PolicyEnforcer
   }
 
   @Override
-  public boolean validate(DataSource unused)
+  public boolean validate(DataSource unused, Policy unused2)
+  {
+    return true;
+  }
+
+  @Override
+  public boolean validate(Segment unused, Policy unused2)
   {
     return true;
   }
diff --git a/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java b/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
index 4881632297cd..b9ae0895a7b9 100644
--- a/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
+++ b/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
@@ -23,6 +23,7 @@
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import org.apache.druid.guice.annotations.UnstableApi;
 import org.apache.druid.query.DataSource;
+import org.apache.druid.segment.Segment;
 
 /**
  * A mechanism for enforcing policies on data sources in Druid queries.
@@ -42,12 +43,25 @@ public interface PolicyEnforcer
 {
 
   /**
-   * Validate a {@link DataSource} against the policy enforcer. The data source must be authorized and include an
-   * attached {@link Policy}, if applicable. The enforcer will validate it before executing any queries on the data
-   * source.
+   * Validate a {@link DataSource} node against the policy enforcer. This method is called during query planning from
+   * {@link DataSource#validate(PolicyEnforcer)}.
+   * <p>
+   * Don't call this method directly, use {@link DataSource#validate(PolicyEnforcer)}.
    *
    * @param ds data source to validate
    * @return true if the data source is valid according to the policy enforcer, false otherwise
    */
-  boolean validate(DataSource ds);
+  boolean validate(DataSource ds, Policy policy);
+
+
+  /**
+   * Validate a {@link Segment} node against the policy enforcer. This method is called during query planning from
+   * {@link Segment#validate(PolicyEnforcer)}.
+   * <p>
+   * Don't call this method directly, use {@link Segment#validate(PolicyEnforcer)}.
+   *
+   * @param segment segment to validate
+   * @return true if the segment is valid according to the policy enforcer, false otherwise
+   */
+  boolean validate(Segment segment, Policy policy);
 }
diff --git a/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java b/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java
index 77ea064ad6e8..522dd1227428 100644
--- a/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java
+++ b/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java
@@ -25,6 +25,8 @@
 import com.google.common.collect.ImmutableList;
 import org.apache.druid.query.DataSource;
 import org.apache.druid.query.RestrictedDataSource;
+import org.apache.druid.segment.RestrictedSegment;
+import org.apache.druid.segment.Segment;
 import org.reflections.Reflections;
 
 import javax.annotation.Nullable;
@@ -65,10 +67,18 @@ public RestrictAllTablesPolicyEnforcer(
   }
 
   @Override
-  public boolean validate(DataSource ds)
+  public boolean validate(DataSource ds, Policy policy)
   {
     if (ds instanceof RestrictedDataSource) {
-      Policy policy = ((RestrictedDataSource) ds).getPolicy();
+      return allowedPolicies.isEmpty() || allowedPolicies.contains(policy.getClass().getSimpleName());
+    }
+    return false;
+  }
+
+  @Override
+  public boolean validate(Segment segment, Policy policy)
+  {
+    if (segment instanceof RestrictedSegment) {
       return allowedPolicies.isEmpty() || allowedPolicies.contains(policy.getClass().getSimpleName());
     }
     return false;
diff --git a/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java b/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java
index c4a7cb4828e8..b48e511e5b52 100644
--- a/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java
+++ b/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java
@@ -21,6 +21,7 @@
 
 import org.apache.druid.query.policy.NoRestrictionPolicy;
 import org.apache.druid.query.policy.Policy;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.timeline.SegmentId;
 import org.joda.time.Interval;
 
@@ -109,6 +110,12 @@ public <T> T as(@Nonnull Class<T> clazz)
     return null;
   }
 
+  @Override
+  public boolean validate(PolicyEnforcer policyEnforcer)
+  {
+    return policyEnforcer.validate(this, policy);
+  }
+
   @Override
   public boolean isTombstone()
   {
diff --git a/processing/src/main/java/org/apache/druid/segment/Segment.java b/processing/src/main/java/org/apache/druid/segment/Segment.java
index 14cd1a4da443..57870db50259 100644
--- a/processing/src/main/java/org/apache/druid/segment/Segment.java
+++ b/processing/src/main/java/org/apache/druid/segment/Segment.java
@@ -22,6 +22,7 @@
 import org.apache.druid.error.DruidException;
 import org.apache.druid.guice.annotations.PublicApi;
 import org.apache.druid.query.datasourcemetadata.DataSourceMetadataResultValue;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.join.table.IndexedTable;
 import org.apache.druid.timeline.SegmentId;
 import org.joda.time.Interval;
@@ -97,12 +98,21 @@ default <T> T as(@Nonnull Class<T> clazz)
     return null;
   }
 
+  /**
+   * Returns true if the segment complies with the policy restrictions on tables.
+   * <p>
+   * This should be called right before the segment is about to be processed by the query stack.
+   */
+  default boolean validate(PolicyEnforcer policyEnforcer)
+  {
+    return policyEnforcer.validate(this, null);
+  }
+
   default boolean isTombstone()
   {
     return false;
   }
 
-
   default String asString()
   {
     return getClass().toString();
diff --git a/processing/src/main/java/org/apache/druid/segment/WrappedSegmentReference.java b/processing/src/main/java/org/apache/druid/segment/WrappedSegmentReference.java
index 97bb1afd4b77..ad132a9e2ec7 100644
--- a/processing/src/main/java/org/apache/druid/segment/WrappedSegmentReference.java
+++ b/processing/src/main/java/org/apache/druid/segment/WrappedSegmentReference.java
@@ -19,6 +19,7 @@
 
 package org.apache.druid.segment;
 
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.timeline.SegmentId;
 import org.joda.time.Interval;
 
@@ -79,6 +80,12 @@ public <T> T as(@Nonnull Class<T> clazz)
     }
   }
 
+  @Override
+  public boolean validate(PolicyEnforcer policyEnforcer)
+  {
+    return delegate.validate(policyEnforcer);
+  }
+
   @Override
   public boolean isTombstone()
   {
diff --git a/processing/src/main/java/org/apache/druid/segment/join/HashJoinSegment.java b/processing/src/main/java/org/apache/druid/segment/join/HashJoinSegment.java
index b6a8da3fbaed..c1ef62037f73 100644
--- a/processing/src/main/java/org/apache/druid/segment/join/HashJoinSegment.java
+++ b/processing/src/main/java/org/apache/druid/segment/join/HashJoinSegment.java
@@ -23,6 +23,7 @@
 import org.apache.druid.java.util.common.io.Closer;
 import org.apache.druid.java.util.common.logger.Logger;
 import org.apache.druid.query.filter.Filter;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.query.rowsandcols.CursorFactoryRowsAndColumns;
 import org.apache.druid.segment.CloseableShapeshifter;
 import org.apache.druid.segment.CursorFactory;
@@ -136,6 +137,12 @@ public <T> T as(Class<T> clazz)
     }
   }
 
+  @Override
+  public boolean validate(PolicyEnforcer policyEnforcer)
+  {
+    return baseSegment.validate(policyEnforcer);
+  }
+
   @Override
   public void close() throws IOException
   {
diff --git a/processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java b/processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java
index e7bcd008b713..7c2166f81637 100644
--- a/processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java
@@ -20,10 +20,16 @@
 package org.apache.druid.query.policy;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.query.RestrictedDataSource;
 import org.apache.druid.query.TableDataSource;
 import org.apache.druid.query.filter.NullFilter;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.RestrictedSegment;
+import org.apache.druid.segment.Segment;
+import org.apache.druid.segment.SegmentReference;
 import org.apache.druid.segment.TestHelper;
+import org.apache.druid.segment.TestSegmentUtils;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -59,8 +65,15 @@ public void test_validate() throws Exception
     TableDataSource table = TableDataSource.create("table");
     RestrictedDataSource restricted = RestrictedDataSource.create(table, policy);
 
-    Assert.assertTrue(policyEnforcer.validate(table));
-    Assert.assertTrue(policyEnforcer.validate(restricted));
+    Assert.assertTrue(policyEnforcer.validate(table, null));
+    Assert.assertTrue(policyEnforcer.validate(restricted, policy));
+
+    Segment baseSegment = new TestSegmentUtils.SegmentForTesting("table", Intervals.ETERNITY, "1");
+    SegmentReference segment = ReferenceCountingSegment.wrapRootGenerationSegment(baseSegment);
+    RestrictedSegment restrictedSegment = new RestrictedSegment(segment, policy);
+    Assert.assertTrue(policyEnforcer.validate(baseSegment, null));
+    Assert.assertTrue(policyEnforcer.validate(segment, null));
+    Assert.assertTrue(policyEnforcer.validate(restrictedSegment, policy));
   }
 
 }
diff --git a/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java b/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
index dcaf8b92b090..de85470cf430 100644
--- a/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
@@ -21,10 +21,16 @@
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.collect.ImmutableList;
+import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.query.RestrictedDataSource;
 import org.apache.druid.query.TableDataSource;
 import org.apache.druid.query.filter.NullFilter;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.RestrictedSegment;
+import org.apache.druid.segment.Segment;
+import org.apache.druid.segment.SegmentReference;
 import org.apache.druid.segment.TestHelper;
+import org.apache.druid.segment.TestSegmentUtils.SegmentForTesting;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -60,8 +66,15 @@ public void test_validate() throws Exception
     TableDataSource table = TableDataSource.create("table");
     RestrictedDataSource restricted = RestrictedDataSource.create(table, policy);
 
-    Assert.assertFalse(policyEnforcer.validate(table));
-    Assert.assertTrue(policyEnforcer.validate(restricted));
+    Assert.assertFalse(policyEnforcer.validate(table, null));
+    Assert.assertTrue(policyEnforcer.validate(restricted, policy));
+
+    Segment baseSegment = new SegmentForTesting("table", Intervals.ETERNITY, "1");
+    SegmentReference segment = ReferenceCountingSegment.wrapRootGenerationSegment(baseSegment);
+    RestrictedSegment restrictedSegment = new RestrictedSegment(segment, policy);
+    Assert.assertFalse(policyEnforcer.validate(baseSegment, null));
+    Assert.assertFalse(policyEnforcer.validate(segment, null));
+    Assert.assertTrue(policyEnforcer.validate(restrictedSegment, policy));
   }
 
   @Test
@@ -73,7 +86,14 @@ public void test_validate_withAllowedPolicies() throws Exception
     TableDataSource table = TableDataSource.create("table");
     RestrictedDataSource restricted = RestrictedDataSource.create(table, policy);
 
-    Assert.assertFalse(policyEnforcer.validate(table));
-    Assert.assertFalse(policyEnforcer.validate(restricted));
+    Assert.assertFalse(policyEnforcer.validate(table, null));
+    Assert.assertFalse(policyEnforcer.validate(restricted, policy));
+
+    Segment baseSegment = new SegmentForTesting("table", Intervals.ETERNITY, "1");
+    SegmentReference segment = ReferenceCountingSegment.wrapRootGenerationSegment(baseSegment);
+    RestrictedSegment restrictedSegment = new RestrictedSegment(segment, policy);
+    Assert.assertFalse(policyEnforcer.validate(baseSegment, null));
+    Assert.assertFalse(policyEnforcer.validate(segment, null));
+    Assert.assertFalse(policyEnforcer.validate(restrictedSegment, policy));
   }
 }
diff --git a/server/src/test/java/org/apache/druid/server/TestSegmentUtils.java b/processing/src/test/java/org/apache/druid/segment/TestSegmentUtils.java
similarity index 94%
rename from server/src/test/java/org/apache/druid/server/TestSegmentUtils.java
rename to processing/src/test/java/org/apache/druid/segment/TestSegmentUtils.java
index 02b4f8c6a277..51e2cfcab916 100644
--- a/server/src/test/java/org/apache/druid/server/TestSegmentUtils.java
+++ b/processing/src/test/java/org/apache/druid/segment/TestSegmentUtils.java
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-package org.apache.druid.server;
+package org.apache.druid.segment;
 
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
@@ -28,15 +28,6 @@
 import org.apache.druid.java.util.common.FileUtils;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.query.OrderBy;
-import org.apache.druid.segment.CursorFactory;
-import org.apache.druid.segment.Cursors;
-import org.apache.druid.segment.DimensionHandler;
-import org.apache.druid.segment.IndexIO;
-import org.apache.druid.segment.Metadata;
-import org.apache.druid.segment.QueryableIndex;
-import org.apache.druid.segment.QueryableIndexCursorFactory;
-import org.apache.druid.segment.Segment;
-import org.apache.druid.segment.SegmentLazyLoadFailCallback;
 import org.apache.druid.segment.column.ColumnHolder;
 import org.apache.druid.segment.data.Indexed;
 import org.apache.druid.segment.loading.LoadSpec;
@@ -58,7 +49,9 @@
 import java.util.Map;
 import java.util.concurrent.ThreadLocalRandom;
 
-
+/**
+ * Test utility class for creating test segments and load specs.
+ */
 public class TestSegmentUtils
 {
   @JsonTypeName("test")
diff --git a/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java b/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
index 28eb6f012a9f..6d510c2e44fd 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
@@ -307,7 +307,7 @@ private <T> QueryRunner<T> buildAndDecorateQueryRunner(
     MetricsEmittingQueryRunner<T> metricsEmittingQueryRunnerInner = new MetricsEmittingQueryRunner<>(
         emitter,
         toolChest,
-        new ReferenceCountingSegmentQueryRunner<>(factory, segment, segmentDescriptor),
+        new ReferenceCountingSegmentQueryRunner<>(factory, segment, segmentDescriptor, policyEnforcer),
         QueryMetrics::reportSegmentTime,
         queryMetrics -> queryMetrics.segment(segmentIdString)
     );
diff --git a/server/src/test/java/org/apache/druid/segment/loading/SegmentLocalCacheManagerTest.java b/server/src/test/java/org/apache/druid/segment/loading/SegmentLocalCacheManagerTest.java
index 1ca73d4b934e..67d72c6ced0f 100644
--- a/server/src/test/java/org/apache/druid/segment/loading/SegmentLocalCacheManagerTest.java
+++ b/server/src/test/java/org/apache/druid/segment/loading/SegmentLocalCacheManagerTest.java
@@ -35,7 +35,7 @@
 import org.apache.druid.segment.SegmentLazyLoadFailCallback;
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.segment.TestIndex;
-import org.apache.druid.server.TestSegmentUtils;
+import org.apache.druid.segment.TestSegmentUtils;
 import org.apache.druid.server.metrics.NoopServiceEmitter;
 import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.partition.NoneShardSpec;
diff --git a/server/src/test/java/org/apache/druid/server/SegmentManagerTest.java b/server/src/test/java/org/apache/druid/server/SegmentManagerTest.java
index 917cee101af7..fbdd12dbd21b 100644
--- a/server/src/test/java/org/apache/druid/server/SegmentManagerTest.java
+++ b/server/src/test/java/org/apache/druid/server/SegmentManagerTest.java
@@ -31,6 +31,7 @@
 import org.apache.druid.segment.SegmentLazyLoadFailCallback;
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.segment.TestIndex;
+import org.apache.druid.segment.TestSegmentUtils;
 import org.apache.druid.segment.loading.LeastBytesUsedStorageLocationSelectorStrategy;
 import org.apache.druid.segment.loading.SegmentLoaderConfig;
 import org.apache.druid.segment.loading.SegmentLoadingException;
diff --git a/server/src/test/java/org/apache/druid/server/TestClusterQuerySegmentWalker.java b/server/src/test/java/org/apache/druid/server/TestClusterQuerySegmentWalker.java
index 8c3db1ddd88b..b8c8fd7fbfb3 100644
--- a/server/src/test/java/org/apache/druid/server/TestClusterQuerySegmentWalker.java
+++ b/server/src/test/java/org/apache/druid/server/TestClusterQuerySegmentWalker.java
@@ -45,6 +45,7 @@
 import org.apache.druid.query.context.ResponseContext.Keys;
 import org.apache.druid.query.groupby.GroupByQueryRunnerTestHelper;
 import org.apache.druid.query.planning.DataSourceAnalysis;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.spec.SpecificSegmentQueryRunner;
 import org.apache.druid.query.spec.SpecificSegmentSpec;
 import org.apache.druid.segment.ReferenceCountingSegment;
@@ -242,7 +243,8 @@ private <T> QueryRunner<T> makeTableRunner(
                                 new ReferenceCountingSegmentQueryRunner<>(
                                     factory,
                                     segmentMapFn.apply(segment.getSegment()),
-                                    segment.getDescriptor()
+                                    segment.getDescriptor(),
+                                    NoopPolicyEnforcer.instance()
                                 ),
                                 new SpecificSegmentSpec(segment.getDescriptor())
                             )
diff --git a/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperCacheTest.java b/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperCacheTest.java
index 17e862a50a9c..3e51cf15be4e 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperCacheTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperCacheTest.java
@@ -27,6 +27,7 @@
 import org.apache.druid.java.util.metrics.StubServiceEmitter;
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.segment.TestIndex;
+import org.apache.druid.segment.TestSegmentUtils;
 import org.apache.druid.segment.loading.DataSegmentPusher;
 import org.apache.druid.segment.loading.LeastBytesUsedStorageLocationSelectorStrategy;
 import org.apache.druid.segment.loading.SegmentLoaderConfig;
@@ -35,7 +36,6 @@
 import org.apache.druid.segment.loading.StorageLocation;
 import org.apache.druid.segment.loading.StorageLocationConfig;
 import org.apache.druid.server.SegmentManager;
-import org.apache.druid.server.TestSegmentUtils;
 import org.apache.druid.server.metrics.DataSourceTaskIdHolder;
 import org.apache.druid.timeline.DataSegment;
 import org.junit.Assert;
diff --git a/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperTest.java b/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperTest.java
index 25ce9a22d153..176ae19d5d06 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/SegmentBootstrapperTest.java
@@ -52,7 +52,7 @@
 import java.util.List;
 import java.util.Set;
 
-import static org.apache.druid.server.TestSegmentUtils.makeSegment;
+import static org.apache.druid.segment.TestSegmentUtils.makeSegment;
 
 public class SegmentBootstrapperTest
 {
diff --git a/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java b/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
index a3cd6c4962aa..bade415887be 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
@@ -53,7 +53,7 @@
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 
-import static org.apache.druid.server.TestSegmentUtils.makeSegment;
+import static org.apache.druid.segment.TestSegmentUtils.makeSegment;
 
 public class SegmentLoadDropHandlerTest
 {
diff --git a/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java b/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
index 26874e555aac..9d99f3712e5c 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
@@ -85,10 +85,10 @@
 import org.apache.druid.query.spec.MultipleSpecificSegmentSpec;
 import org.apache.druid.segment.ReferenceCountingSegment;
 import org.apache.druid.segment.Segment;
+import org.apache.druid.segment.TestSegmentUtils;
+import org.apache.druid.segment.TestSegmentUtils.SegmentForTesting;
 import org.apache.druid.segment.loading.SegmentLoadingException;
 import org.apache.druid.server.SegmentManager;
-import org.apache.druid.server.TestSegmentUtils;
-import org.apache.druid.server.TestSegmentUtils.SegmentForTesting;
 import org.apache.druid.server.initialization.ServerConfig;
 import org.apache.druid.server.metrics.NoopServiceEmitter;
 import org.apache.druid.test.utils.TestSegmentCacheManager;
diff --git a/server/src/test/java/org/apache/druid/test/utils/TestSegmentCacheManager.java b/server/src/test/java/org/apache/druid/test/utils/TestSegmentCacheManager.java
index 0f6020460e0f..f212f8c15404 100644
--- a/server/src/test/java/org/apache/druid/test/utils/TestSegmentCacheManager.java
+++ b/server/src/test/java/org/apache/druid/test/utils/TestSegmentCacheManager.java
@@ -24,9 +24,9 @@
 import org.apache.druid.java.util.common.MapUtils;
 import org.apache.druid.segment.ReferenceCountingSegment;
 import org.apache.druid.segment.SegmentLazyLoadFailCallback;
+import org.apache.druid.segment.TestSegmentUtils;
 import org.apache.druid.segment.loading.NoopSegmentCacheManager;
 import org.apache.druid.segment.loading.TombstoneSegmentizerFactory;
-import org.apache.druid.server.TestSegmentUtils;
 import org.apache.druid.timeline.DataSegment;
 import org.joda.time.Interval;
 

From b2a9ef4e1ac7b99d4d848de3c95ba8f6950f285f Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Thu, 3 Apr 2025 12:26:27 -0700
Subject: [PATCH 75/99] inject policy enforcer

---
 .../org/apache/druid/sql/calcite/util/SqlTestFramework.java    | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
index 7803b9082aae..e09e60bd0640 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
@@ -48,6 +48,7 @@
 import org.apache.druid.guice.annotations.Global;
 import org.apache.druid.guice.annotations.Merging;
 import org.apache.druid.guice.annotations.Self;
+import org.apache.druid.guice.security.PolicyModule;
 import org.apache.druid.initialization.CoreInjectorBuilder;
 import org.apache.druid.initialization.DruidModule;
 import org.apache.druid.initialization.ServiceInjectorBuilder;
@@ -396,12 +397,14 @@ protected PlannerComponentSupplier buildPlannerComponentSupplier()
     @Override
     public void gatherProperties(Properties properties)
     {
+      properties.setProperty("druid.policy.enforcer.type", "none");
     }
 
     @Override
     public DruidModule getCoreModule()
     {
       return DruidModuleCollection.of(
+          new PolicyModule(),
           new LookylooModule(),
           new SegmentWranglerModule(),
           new ExpressionModule(),

From 9063bd059edf35f10eda23d71c64dfd754e36d47 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Thu, 3 Apr 2025 16:40:49 -0700
Subject: [PATCH 76/99] add PolicyEnforcer binding in MSQTestBase

---
 .../src/test/java/org/apache/druid/msq/test/MSQTestBase.java | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestBase.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestBase.java
index 609f2d1140f5..2263964cb996 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestBase.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestBase.java
@@ -133,6 +133,8 @@
 import org.apache.druid.query.groupby.GroupByQueryRunnerTest;
 import org.apache.druid.query.groupby.GroupingEngine;
 import org.apache.druid.query.groupby.TestGroupByBuffers;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.rpc.ServiceClientFactory;
 import org.apache.druid.segment.AggregateProjectionMetadata;
 import org.apache.druid.segment.CompleteSegment;
@@ -539,7 +541,8 @@ public String getFormatString()
         new SegmentWranglerModule(),
         new HllSketchModule(),
         binder -> binder.bind(BrokerClient.class).toInstance(brokerClient),
-        binder -> binder.bind(Bouncer.class).toInstance(new Bouncer(1))
+        binder -> binder.bind(Bouncer.class).toInstance(new Bouncer(1)),
+        binder -> binder.bind(PolicyEnforcer.class).toInstance(NoopPolicyEnforcer.instance())
     );
     // adding node role injection to the modules, since CliPeon would also do that through run method
     injector = new CoreInjectorBuilder(new StartupInjectorBuilder().build(), ImmutableSet.of(NodeRole.PEON))

From 0f14f5777ee7b463350d6ac6d97d71ff5ad58eb8 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Fri, 4 Apr 2025 10:21:54 -0700
Subject: [PATCH 77/99] add check in SinkQuerySegmentWalker

---
 .../druid/indexing/common/TaskToolbox.java    | 18 +++++++++++
 .../SeekableStreamIndexTask.java              |  1 +
 .../common/task/TestAppenderatorsManager.java |  3 ++
 ...stractParallelIndexSupervisorTaskTest.java |  2 ++
 .../indexing/overlord/TaskLifecycleTest.java  |  2 ++
 .../apache/druid/guice/JsonConfigurator.java  | 30 +++++++++++++++++--
 .../druid/query/policy/PolicyEnforcer.java    | 26 ++++++++--------
 .../druid/guice/security/PolicyModule.java    |  3 +-
 .../realtime/appenderator/Appenderators.java  |  5 +++-
 .../appenderator/AppenderatorsManager.java    |  2 ++
 ...DummyForInjectionAppenderatorsManager.java |  2 ++
 .../PeonAppenderatorsManager.java             |  3 ++
 .../appenderator/SinkQuerySegmentWalker.java  | 13 +++++++-
 .../UnifiedIndexerAppenderatorsManager.java   |  8 ++++-
 .../guice/security/PolicyModuleTest.java      | 24 +++++++++++++--
 .../StreamAppenderatorTester.java             |  3 ++
 ...nifiedIndexerAppenderatorsManagerTest.java |  2 ++
 17 files changed, 126 insertions(+), 21 deletions(-)

diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/TaskToolbox.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/TaskToolbox.java
index 9732d72eaf5e..e60afa153d73 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/TaskToolbox.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/TaskToolbox.java
@@ -45,6 +45,7 @@
 import org.apache.druid.java.util.metrics.MonitorScheduler;
 import org.apache.druid.query.QueryProcessingPool;
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.rpc.indexing.OverlordClient;
 import org.apache.druid.segment.IndexIO;
 import org.apache.druid.segment.IndexMergerV9;
@@ -110,6 +111,7 @@ public class TaskToolbox
   private final Cache cache;
   private final CacheConfig cacheConfig;
   private final CachePopulatorStats cachePopulatorStats;
+  private final PolicyEnforcer policyEnforcer;
   private final IndexMergerV9 indexMergerV9;
   private final TaskReportFileWriter taskReportFileWriter;
 
@@ -158,6 +160,7 @@ public TaskToolbox(
       Cache cache,
       CacheConfig cacheConfig,
       CachePopulatorStats cachePopulatorStats,
+      PolicyEnforcer policyEnforcer,
       IndexMergerV9 indexMergerV9,
       DruidNodeAnnouncer druidNodeAnnouncer,
       DruidNode druidNode,
@@ -201,6 +204,7 @@ public TaskToolbox(
     this.cache = cache;
     this.cacheConfig = cacheConfig;
     this.cachePopulatorStats = cachePopulatorStats;
+    this.policyEnforcer = policyEnforcer;
     this.indexMergerV9 = Preconditions.checkNotNull(indexMergerV9, "Null IndexMergerV9");
     this.druidNodeAnnouncer = druidNodeAnnouncer;
     this.druidNode = druidNode;
@@ -375,6 +379,11 @@ public CachePopulatorStats getCachePopulatorStats()
     return cachePopulatorStats;
   }
 
+  public PolicyEnforcer getPolicyEnforcer()
+  {
+    return policyEnforcer;
+  }
+
   public IndexMergerV9 getIndexMergerV9()
   {
     return indexMergerV9;
@@ -546,6 +555,7 @@ public static class Builder
     private Cache cache;
     private CacheConfig cacheConfig;
     private CachePopulatorStats cachePopulatorStats;
+    private PolicyEnforcer policyEnforcer;
     private IndexMergerV9 indexMergerV9;
     private DruidNodeAnnouncer druidNodeAnnouncer;
     private DruidNode druidNode;
@@ -594,6 +604,7 @@ public Builder(TaskToolbox other)
       this.cache = other.cache;
       this.cacheConfig = other.cacheConfig;
       this.cachePopulatorStats = other.cachePopulatorStats;
+      this.policyEnforcer = other.policyEnforcer;
       this.indexMergerV9 = other.indexMergerV9;
       this.druidNodeAnnouncer = other.druidNodeAnnouncer;
       this.druidNode = other.druidNode;
@@ -750,6 +761,12 @@ public Builder cachePopulatorStats(final CachePopulatorStats cachePopulatorStats
       return this;
     }
 
+    public Builder policyEnforcer(final PolicyEnforcer policyEnforcer)
+    {
+      this.policyEnforcer = policyEnforcer;
+      return this;
+    }
+
     public Builder indexMergerV9(final IndexMergerV9 indexMergerV9)
     {
       this.indexMergerV9 = indexMergerV9;
@@ -884,6 +901,7 @@ public TaskToolbox build()
           cache,
           cacheConfig,
           cachePopulatorStats,
+          policyEnforcer,
           indexMergerV9,
           druidNodeAnnouncer,
           druidNode,
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTask.java b/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTask.java
index 7b10c0afdccf..d932295c2bbf 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTask.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTask.java
@@ -214,6 +214,7 @@ public Appenderator newAppenderator(
         toolbox.getCache(),
         toolbox.getCacheConfig(),
         toolbox.getCachePopulatorStats(),
+        toolbox.getPolicyEnforcer(),
         rowIngestionMeters,
         parseExceptionHandler,
         isUseMaxMemoryEstimates(),
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/common/task/TestAppenderatorsManager.java b/indexing-service/src/test/java/org/apache/druid/indexing/common/task/TestAppenderatorsManager.java
index 417195326fb4..56b8675eaabe 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/common/task/TestAppenderatorsManager.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/common/task/TestAppenderatorsManager.java
@@ -29,6 +29,7 @@
 import org.apache.druid.query.QueryRunner;
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
 import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.IndexIO;
 import org.apache.druid.segment.IndexMerger;
 import org.apache.druid.segment.incremental.ParseExceptionHandler;
@@ -69,6 +70,7 @@ public Appenderator createRealtimeAppenderatorForTask(
       Cache cache,
       CacheConfig cacheConfig,
       CachePopulatorStats cachePopulatorStats,
+      PolicyEnforcer policyEnforcer,
       RowIngestionMeters rowIngestionMeters,
       ParseExceptionHandler parseExceptionHandler,
       boolean useMaxMemoryEstimates,
@@ -92,6 +94,7 @@ public Appenderator createRealtimeAppenderatorForTask(
         cache,
         cacheConfig,
         cachePopulatorStats,
+        policyEnforcer,
         rowIngestionMeters,
         parseExceptionHandler,
         useMaxMemoryEstimates,
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/common/task/batch/parallel/AbstractParallelIndexSupervisorTaskTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/common/task/batch/parallel/AbstractParallelIndexSupervisorTaskTest.java
index c599854055f2..6c251ea584ca 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/common/task/batch/parallel/AbstractParallelIndexSupervisorTaskTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/common/task/batch/parallel/AbstractParallelIndexSupervisorTaskTest.java
@@ -82,6 +82,7 @@
 import org.apache.druid.query.aggregation.AggregatorFactory;
 import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
 import org.apache.druid.query.expression.LookupEnabledTestExprMacroTable;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.rpc.indexing.NoopOverlordClient;
 import org.apache.druid.segment.DataSegmentsWithSchemas;
 import org.apache.druid.segment.IndexIO;
@@ -688,6 +689,7 @@ public File getStorageDirectory()
         .indexMergerV9(getIndexMergerV9Factory().create(task.getContextValue(Tasks.STORE_EMPTY_COLUMNS_KEY, true)))
         .intermediaryDataManager(intermediaryDataManager)
         .taskReportFileWriter(new SingleFileTaskReportFileWriter(reportsFile))
+        .policyEnforcer(NoopPolicyEnforcer.instance())
         .authorizerMapper(AuthTestUtils.TEST_AUTHORIZER_MAPPER)
         .chatHandlerProvider(new NoopChatHandlerProvider())
         .rowIngestionMetersFactory(new TestUtils().getRowIngestionMetersFactory())
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLifecycleTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLifecycleTest.java
index e6535fdadc90..ab090c79b90a 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLifecycleTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLifecycleTest.java
@@ -110,6 +110,7 @@
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
 import org.apache.druid.query.SegmentDescriptor;
 import org.apache.druid.query.aggregation.DoubleSumAggregatorFactory;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.rpc.indexing.NoopOverlordClient;
 import org.apache.druid.segment.IndexIO;
 import org.apache.druid.segment.IndexMergerV9Factory;
@@ -1243,6 +1244,7 @@ public void testUnifiedAppenderatorsManagerCleanup() throws Exception
         MapCache.create(2048),
         new CacheConfig(),
         new CachePopulatorStats(),
+        NoopPolicyEnforcer.instance(),
         MAPPER,
         new NoopServiceEmitter(),
         () -> queryRunnerFactoryConglomerate
diff --git a/processing/src/main/java/org/apache/druid/guice/JsonConfigurator.java b/processing/src/main/java/org/apache/druid/guice/JsonConfigurator.java
index 2d7db35e2acb..940bee2565ee 100644
--- a/processing/src/main/java/org/apache/druid/guice/JsonConfigurator.java
+++ b/processing/src/main/java/org/apache/druid/guice/JsonConfigurator.java
@@ -20,6 +20,7 @@
 package org.apache.druid.guice;
 
 import com.fasterxml.jackson.annotation.JacksonInject;
+import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.introspect.AnnotatedField;
@@ -45,15 +46,19 @@
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Properties;
 import java.util.Set;
 
 /**
+ *
  */
 public class JsonConfigurator
 {
@@ -125,8 +130,14 @@ public <T> T configurate(
     try {
       if (defaultClass != null && jsonMap.isEmpty()) {
         // No configs were provided. Don't use the jsonMapper; instead create a default instance of the default class
-        // using the no-arg constructor. We know it exists because verifyClazzIsConfigurable checks for it.
-        config = defaultClass.getConstructor().newInstance();
+        // using the JsonCreator annotated factory method or no-arg constructor.
+        // We know it exists because verifyClazzIsConfigurable checks for it.
+        Optional<Method> factoryMethod = findJsonCreatorFactoryMethod(defaultClass);
+        if (factoryMethod.isPresent()) {
+          config = (T) factoryMethod.get().invoke(null);
+        } else {
+          config = defaultClass.getConstructor().newInstance();
+        }
       } else {
         config = jsonMapper.convertValue(jsonMap, clazz);
       }
@@ -256,7 +267,9 @@ public static <T> void verifyClazzIsConfigurable(
   {
     if (defaultClass != null) {
       try {
-        defaultClass.getConstructor();
+        if (findJsonCreatorFactoryMethod(defaultClass).isEmpty()) {
+          defaultClass.getConstructor();
+        }
       }
       catch (NoSuchMethodException e) {
         throw new ProvisionException(
@@ -283,4 +296,15 @@ public static <T> void verifyClazzIsConfigurable(
       }
     }
   }
+
+  private static <T> Optional<Method> findJsonCreatorFactoryMethod(Class<T> clazz)
+  {
+    return Arrays.stream(clazz.getMethods())
+                 .filter(m -> m.getAnnotation(JsonCreator.class) != null
+                              && m.getParameterCount() == 0
+                              && m.getReturnType()
+                                  .equals(clazz))
+                 .findFirst();
+
+  }
 }
diff --git a/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java b/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
index b9ae0895a7b9..3212082bcb40 100644
--- a/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
+++ b/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
@@ -26,7 +26,7 @@
 import org.apache.druid.segment.Segment;
 
 /**
- * A mechanism for enforcing policies on data sources in Druid queries.
+ * Interface for enforcing policies on data sources and segments in Druid queries.
  * <p>
  * Note: The {@code PolicyEnforcer} is intended to serve as a sanity checker and not as a primary authorization mechanism.
  * It should not be used to implement security rules. Instead, it acts as a last line of defense to verify that
@@ -43,25 +43,27 @@ public interface PolicyEnforcer
 {
 
   /**
-   * Validate a {@link DataSource} node against the policy enforcer. This method is called during query planning from
-   * {@link DataSource#validate(PolicyEnforcer)}.
+   * Validates a {@link DataSource} against the policy enforcer. This method is invoked during query planning
+   * via {@link DataSource#validate(PolicyEnforcer)}.
    * <p>
-   * Don't call this method directly, use {@link DataSource#validate(PolicyEnforcer)}.
+   * Direct invocation of this method is discouraged; use {@link DataSource#validate(PolicyEnforcer)} instead.
    *
-   * @param ds data source to validate
-   * @return true if the data source is valid according to the policy enforcer, false otherwise
+   * @param ds the data source to validate
+   * @param policy the policy on the data source, e.x. {@link RestrictedDataSource#policy} or null for {@link TableDataSource}
+   * @return {@code true} if the data source complies with the policy, {@code false} otherwise
    */
   boolean validate(DataSource ds, Policy policy);
 
-
   /**
-   * Validate a {@link Segment} node against the policy enforcer. This method is called during query planning from
-   * {@link Segment#validate(PolicyEnforcer)}.
+   * Validates a {@link Segment} against the policy enforcer. This method is invoked during query planning
+   * via {@link Segment#validate(PolicyEnforcer)}.
    * <p>
-   * Don't call this method directly, use {@link Segment#validate(PolicyEnforcer)}.
+   * Direct invocation of this method is discouraged; use {@link Segment#validate(PolicyEnforcer)} instead.
+
    *
-   * @param segment segment to validate
-   * @return true if the segment is valid according to the policy enforcer, false otherwise
+   * @param segment the segment to validate
+   * @param policy the policy on the segment, {@link RestrictedSegment#policy}
+   * @return {@code true} if the segment complies with the policy, {@code false} otherwise
    */
   boolean validate(Segment segment, Policy policy);
 }
diff --git a/server/src/main/java/org/apache/druid/guice/security/PolicyModule.java b/server/src/main/java/org/apache/druid/guice/security/PolicyModule.java
index 6ddb332b39e7..9e6919c253b8 100644
--- a/server/src/main/java/org/apache/druid/guice/security/PolicyModule.java
+++ b/server/src/main/java/org/apache/druid/guice/security/PolicyModule.java
@@ -22,6 +22,7 @@
 import com.google.inject.Binder;
 import org.apache.druid.guice.JsonConfigProvider;
 import org.apache.druid.initialization.DruidModule;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.policy.PolicyEnforcer;
 
 /**
@@ -32,6 +33,6 @@ public class PolicyModule implements DruidModule
   @Override
   public void configure(Binder binder)
   {
-    JsonConfigProvider.bind(binder, "druid.policy.enforcer", PolicyEnforcer.class);
+    JsonConfigProvider.bindWithDefault(binder, "druid.policy.enforcer", PolicyEnforcer.class, NoopPolicyEnforcer.class);
   }
 }
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderators.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderators.java
index 28b4379f7b98..09442e7226b6 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderators.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderators.java
@@ -27,6 +27,7 @@
 import org.apache.druid.java.util.emitter.service.ServiceEmitter;
 import org.apache.druid.query.QueryProcessingPool;
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.IndexIO;
 import org.apache.druid.segment.IndexMerger;
 import org.apache.druid.segment.incremental.ParseExceptionHandler;
@@ -58,6 +59,7 @@ public static Appenderator createRealtime(
       Cache cache,
       CacheConfig cacheConfig,
       CachePopulatorStats cachePopulatorStats,
+      PolicyEnforcer policyEnforcer,
       RowIngestionMeters rowIngestionMeters,
       ParseExceptionHandler parseExceptionHandler,
       boolean useMaxMemoryEstimates,
@@ -84,7 +86,8 @@ public static Appenderator createRealtime(
             queryProcessingPool,
             Preconditions.checkNotNull(cache, "cache"),
             cacheConfig,
-            cachePopulatorStats
+            cachePopulatorStats,
+            policyEnforcer
         ),
         indexIO,
         indexMerger,
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorsManager.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorsManager.java
index ec328c3b3cd4..8b565e8193b5 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorsManager.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorsManager.java
@@ -29,6 +29,7 @@
 import org.apache.druid.query.QueryRunner;
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
 import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.IndexIO;
 import org.apache.druid.segment.IndexMerger;
 import org.apache.druid.segment.incremental.ParseExceptionHandler;
@@ -84,6 +85,7 @@ Appenderator createRealtimeAppenderatorForTask(
       Cache cache,
       CacheConfig cacheConfig,
       CachePopulatorStats cachePopulatorStats,
+      PolicyEnforcer policyEnforcer,
       RowIngestionMeters rowIngestionMeters,
       ParseExceptionHandler parseExceptionHandler,
       boolean useMaxMemoryEstimates,
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/DummyForInjectionAppenderatorsManager.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/DummyForInjectionAppenderatorsManager.java
index d613f3ff59ce..ff716ce42dc1 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/DummyForInjectionAppenderatorsManager.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/DummyForInjectionAppenderatorsManager.java
@@ -30,6 +30,7 @@
 import org.apache.druid.query.QueryRunner;
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
 import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.IndexIO;
 import org.apache.druid.segment.IndexMerger;
 import org.apache.druid.segment.incremental.ParseExceptionHandler;
@@ -74,6 +75,7 @@ public Appenderator createRealtimeAppenderatorForTask(
       Cache cache,
       CacheConfig cacheConfig,
       CachePopulatorStats cachePopulatorStats,
+      PolicyEnforcer policyEnforcer,
       RowIngestionMeters rowIngestionMeters,
       ParseExceptionHandler parseExceptionHandler,
       boolean useMaxMemoryEstimates,
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/PeonAppenderatorsManager.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/PeonAppenderatorsManager.java
index 998f674daf7c..d1dd208e2a9e 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/PeonAppenderatorsManager.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/PeonAppenderatorsManager.java
@@ -30,6 +30,7 @@
 import org.apache.druid.query.QueryRunner;
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
 import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.IndexIO;
 import org.apache.druid.segment.IndexMerger;
 import org.apache.druid.segment.incremental.ParseExceptionHandler;
@@ -80,6 +81,7 @@ public Appenderator createRealtimeAppenderatorForTask(
       Cache cache,
       CacheConfig cacheConfig,
       CachePopulatorStats cachePopulatorStats,
+      PolicyEnforcer policyEnforcer,
       RowIngestionMeters rowIngestionMeters,
       ParseExceptionHandler parseExceptionHandler,
       boolean useMaxMemoryEstimates,
@@ -108,6 +110,7 @@ public Appenderator createRealtimeAppenderatorForTask(
           cache,
           cacheConfig,
           cachePopulatorStats,
+          policyEnforcer,
           rowIngestionMeters,
           parseExceptionHandler,
           useMaxMemoryEstimates,
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SinkQuerySegmentWalker.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SinkQuerySegmentWalker.java
index 09d07db304f1..428ff8b0976d 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SinkQuerySegmentWalker.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SinkQuerySegmentWalker.java
@@ -29,6 +29,7 @@
 import org.apache.druid.client.cache.CacheConfig;
 import org.apache.druid.client.cache.CachePopulatorStats;
 import org.apache.druid.client.cache.ForegroundCachePopulator;
+import org.apache.druid.error.DruidException;
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.Pair;
 import org.apache.druid.java.util.common.guava.FunctionalIterable;
@@ -61,6 +62,7 @@
 import org.apache.druid.query.SinkQueryRunners;
 import org.apache.druid.query.context.ResponseContext;
 import org.apache.druid.query.planning.DataSourceAnalysis;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.query.spec.SpecificSegmentQueryRunner;
 import org.apache.druid.query.spec.SpecificSegmentSpec;
 import org.apache.druid.segment.SegmentReference;
@@ -125,6 +127,7 @@ public class SinkQuerySegmentWalker implements QuerySegmentWalker
   private final Cache cache;
   private final CacheConfig cacheConfig;
   private final CachePopulatorStats cachePopulatorStats;
+  private final PolicyEnforcer policyEnforcer;
 
   public SinkQuerySegmentWalker(
       String dataSource,
@@ -135,7 +138,8 @@ public SinkQuerySegmentWalker(
       QueryProcessingPool queryProcessingPool,
       Cache cache,
       CacheConfig cacheConfig,
-      CachePopulatorStats cachePopulatorStats
+      CachePopulatorStats cachePopulatorStats,
+      PolicyEnforcer policyEnforcer
   )
   {
     this.dataSource = Preconditions.checkNotNull(dataSource, "dataSource");
@@ -147,6 +151,7 @@ public SinkQuerySegmentWalker(
     this.cache = Preconditions.checkNotNull(cache, "cache");
     this.cacheConfig = Preconditions.checkNotNull(cacheConfig, "cacheConfig");
     this.cachePopulatorStats = Preconditions.checkNotNull(cachePopulatorStats, "cachePopulatorStats");
+    this.policyEnforcer = policyEnforcer;
 
     if (!cache.isLocal()) {
       log.warn("Configured cache[%s] is not local, caching will not be enabled.", cache.getClass().getName());
@@ -201,6 +206,12 @@ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final
       throw new ISE("Cannot handle subquery: %s", dataSourceFromQuery);
     }
 
+    if (!dataSourceFromQuery.validate(policyEnforcer)) {
+      throw DruidException.forPersona(DruidException.Persona.OPERATOR)
+                          .ofCategory(DruidException.Category.FORBIDDEN)
+                          .build("Failed security validation with dataSource [%s]", dataSourceFromQuery);
+    }
+
     // segmentMapFn maps each base Segment into a joined Segment if necessary.
     final Function<SegmentReference, SegmentReference> segmentMapFn = JvmUtils.safeAccumulateThreadCpuTime(
         cpuTimeAccumulator,
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/UnifiedIndexerAppenderatorsManager.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/UnifiedIndexerAppenderatorsManager.java
index 36eaf51c1c3f..c7d7900b0fc3 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/UnifiedIndexerAppenderatorsManager.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/UnifiedIndexerAppenderatorsManager.java
@@ -46,6 +46,7 @@
 import org.apache.druid.query.TableDataSource;
 import org.apache.druid.query.aggregation.AggregatorFactory;
 import org.apache.druid.query.planning.DataSourceAnalysis;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.BaseProgressIndicator;
 import org.apache.druid.segment.IndexIO;
 import org.apache.druid.segment.IndexMerger;
@@ -113,6 +114,7 @@ public class UnifiedIndexerAppenderatorsManager implements AppenderatorsManager
   private final Cache cache;
   private final CacheConfig cacheConfig;
   private final CachePopulatorStats cachePopulatorStats;
+  private final PolicyEnforcer policyEnforcer;
   private final ObjectMapper objectMapper;
   private final ServiceEmitter serviceEmitter;
   private final Provider<QueryRunnerFactoryConglomerate> queryRunnerFactoryConglomerateProvider;
@@ -127,6 +129,7 @@ public UnifiedIndexerAppenderatorsManager(
       Cache cache,
       CacheConfig cacheConfig,
       CachePopulatorStats cachePopulatorStats,
+      PolicyEnforcer policyEnforcer,
       ObjectMapper objectMapper,
       ServiceEmitter serviceEmitter,
       Provider<QueryRunnerFactoryConglomerate> queryRunnerFactoryConglomerateProvider
@@ -138,6 +141,7 @@ public UnifiedIndexerAppenderatorsManager(
     this.cache = cache;
     this.cacheConfig = cacheConfig;
     this.cachePopulatorStats = cachePopulatorStats;
+    this.policyEnforcer = policyEnforcer;
     this.objectMapper = objectMapper;
     this.serviceEmitter = serviceEmitter;
     this.queryRunnerFactoryConglomerateProvider = queryRunnerFactoryConglomerateProvider;
@@ -166,6 +170,7 @@ public Appenderator createRealtimeAppenderatorForTask(
       Cache cache,
       CacheConfig cacheConfig,
       CachePopulatorStats cachePopulatorStats,
+      PolicyEnforcer policyEnforcer,
       RowIngestionMeters rowIngestionMeters,
       ParseExceptionHandler parseExceptionHandler,
       boolean useMaxMemoryEstimates,
@@ -357,7 +362,8 @@ public DatasourceBundle(
           queryProcessingPool,
           Preconditions.checkNotNull(cache, "cache"),
           cacheConfig,
-          cachePopulatorStats
+          cachePopulatorStats,
+          policyEnforcer
       );
     }
 
diff --git a/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java b/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
index ad3f64e0cbd1..4304ef02871c 100644
--- a/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
+++ b/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
@@ -38,10 +38,9 @@
 public class PolicyModuleTest
 {
   @Test
-  public void testConfigNoopPolicyEnforcer()
+  public void testDefaultConfigNoopPolicyEnforcer()
   {
     Properties properties = new Properties();
-    properties.setProperty("druid.policy.enforcer.type", "none");
     PolicyEnforcer policyEnforcer = Guice.createInjector(
         binder -> binder.bind(Properties.class).toInstance(properties),
         new DruidGuiceExtensions(),
@@ -52,6 +51,27 @@ public void testConfigNoopPolicyEnforcer()
     Assert.assertTrue(policyEnforcer instanceof NoopPolicyEnforcer);
   }
 
+  @Test
+  public void testConfigThrowForUnrecognizedType()
+  {
+    Properties properties = new Properties();
+    properties.setProperty("druid.policy.enforcer.type", "unrecognizedType");
+    Injector injector = Guice.createInjector(
+        binder -> binder.bind(Properties.class).toInstance(properties),
+        new DruidGuiceExtensions(),
+        new ConfigModule(),
+        new PolicyModule()
+    );
+    ProvisionException e = Assert.assertThrows(
+        ProvisionException.class,
+        () -> injector.getInstance(Key.get(PolicyEnforcer.class))
+    );
+    Assert.assertTrue(e.getCause()
+                       .getMessage()
+                       .contains(
+                           "Could not resolve type id 'unrecognizedType' as a subtype of `org.apache.druid.query.policy.PolicyEnforcer`"));
+  }
+
   @Test
   public void testConfigRestrictAllTablesPolicyEnforcer()
   {
diff --git a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTester.java b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTester.java
index 6f9bf400b0fd..71e980eaaa89 100644
--- a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTester.java
+++ b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTester.java
@@ -48,6 +48,7 @@
 import org.apache.druid.query.aggregation.CountAggregatorFactory;
 import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
 import org.apache.druid.query.expression.TestExprMacroTable;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.scan.ScanQuery;
 import org.apache.druid.query.scan.ScanQueryConfig;
 import org.apache.druid.query.scan.ScanQueryEngine;
@@ -244,6 +245,7 @@ ScanQuery.class, new ScanQueryRunnerFactory(
           MapCache.create(2048),
           new CacheConfig(),
           new CachePopulatorStats(),
+          NoopPolicyEnforcer.instance(),
           rowIngestionMeters,
           new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
           true,
@@ -286,6 +288,7 @@ ScanQuery.class, new ScanQueryRunnerFactory(
           MapCache.create(2048),
           new CacheConfig(),
           new CachePopulatorStats(),
+          NoopPolicyEnforcer.instance(),
           rowIngestionMeters,
           new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
           true,
diff --git a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/UnifiedIndexerAppenderatorsManagerTest.java b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/UnifiedIndexerAppenderatorsManagerTest.java
index e92df0f65183..3a684027e23b 100644
--- a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/UnifiedIndexerAppenderatorsManagerTest.java
+++ b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/UnifiedIndexerAppenderatorsManagerTest.java
@@ -34,6 +34,7 @@
 import org.apache.druid.query.DirectQueryProcessingPool;
 import org.apache.druid.query.Druids;
 import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.scan.ScanQuery;
 import org.apache.druid.query.spec.MultipleIntervalSegmentSpec;
 import org.apache.druid.segment.IndexMerger;
@@ -81,6 +82,7 @@ public class UnifiedIndexerAppenderatorsManagerTest extends InitializedNullHandl
       MapCache.create(10),
       new CacheConfig(),
       new CachePopulatorStats(),
+      NoopPolicyEnforcer.instance(),
       TestHelper.makeJsonMapper(),
       new NoopServiceEmitter(),
       () -> DefaultQueryRunnerFactoryConglomerate.buildFromQueryRunnerFactories(ImmutableMap.of())

From 43442551f1a235bf5dcce72161b5d4b11f527083 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Fri, 4 Apr 2025 11:58:40 -0700
Subject: [PATCH 78/99] more tests in realtime server

---
 .../druid/indexing/common/TaskToolbox.java    | 22 +++++-----
 .../indexing/common/TaskToolboxFactory.java   |  5 +++
 .../indexing/common/TaskToolboxTest.java      |  2 +
 .../SingleTaskBackgroundRunnerTest.java       |  2 +
 .../indexing/overlord/TaskLifecycleTest.java  |  1 +
 .../overlord/TestTaskToolboxFactory.java      |  9 ++++
 .../SeekableStreamIndexTaskTestBase.java      |  2 +
 .../worker/WorkerTaskManagerTest.java         |  2 +
 .../worker/WorkerTaskMonitorTest.java         |  2 +
 .../appenderator/StreamAppenderatorTest.java  | 43 +++++++++++++++++++
 .../StreamAppenderatorTester.java             | 19 ++++++--
 .../java/org/apache/druid/cli/CliPeon.java    |  1 +
 .../org/apache/druid/cli/CliPeonTest.java     | 19 ++++++++
 13 files changed, 114 insertions(+), 15 deletions(-)

diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/TaskToolbox.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/TaskToolbox.java
index e60afa153d73..963196729de2 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/TaskToolbox.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/TaskToolbox.java
@@ -251,6 +251,11 @@ public ServiceEmitter getEmitter()
     return emitter;
   }
 
+  public PolicyEnforcer getPolicyEnforcer()
+  {
+    return policyEnforcer;
+  }
+
   public DataSegmentPusher getSegmentPusher()
   {
     return segmentPusher;
@@ -379,11 +384,6 @@ public CachePopulatorStats getCachePopulatorStats()
     return cachePopulatorStats;
   }
 
-  public PolicyEnforcer getPolicyEnforcer()
-  {
-    return policyEnforcer;
-  }
-
   public IndexMergerV9 getIndexMergerV9()
   {
     return indexMergerV9;
@@ -653,6 +653,12 @@ public Builder emitter(final ServiceEmitter emitter)
       return this;
     }
 
+    public Builder policyEnforcer(final PolicyEnforcer policyEnforcer)
+    {
+      this.policyEnforcer = policyEnforcer;
+      return this;
+    }
+
     public Builder segmentPusher(final DataSegmentPusher segmentPusher)
     {
       this.segmentPusher = segmentPusher;
@@ -761,12 +767,6 @@ public Builder cachePopulatorStats(final CachePopulatorStats cachePopulatorStats
       return this;
     }
 
-    public Builder policyEnforcer(final PolicyEnforcer policyEnforcer)
-    {
-      this.policyEnforcer = policyEnforcer;
-      return this;
-    }
-
     public Builder indexMergerV9(final IndexMergerV9 indexMergerV9)
     {
       this.indexMergerV9 = indexMergerV9;
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/TaskToolboxFactory.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/TaskToolboxFactory.java
index 7190c38849f2..f455dceb0d88 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/TaskToolboxFactory.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/TaskToolboxFactory.java
@@ -46,6 +46,7 @@
 import org.apache.druid.java.util.metrics.MonitorScheduler;
 import org.apache.druid.query.QueryProcessingPool;
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.rpc.StandardRetryPolicy;
 import org.apache.druid.rpc.indexing.OverlordClient;
 import org.apache.druid.segment.IndexIO;
@@ -80,6 +81,7 @@ public class TaskToolboxFactory
   private final DruidNode taskExecutorNode;
   private final TaskActionClientFactory taskActionClientFactory;
   private final ServiceEmitter emitter;
+  private final PolicyEnforcer policyEnforcer;
   private final DataSegmentPusher segmentPusher;
   private final DataSegmentKiller dataSegmentKiller;
   private final DataSegmentMover dataSegmentMover;
@@ -125,6 +127,7 @@ public TaskToolboxFactory(
       @Parent DruidNode taskExecutorNode,
       TaskActionClientFactory taskActionClientFactory,
       ServiceEmitter emitter,
+      PolicyEnforcer policyEnforcer,
       DataSegmentPusher segmentPusher,
       DataSegmentKiller dataSegmentKiller,
       DataSegmentMover dataSegmentMover,
@@ -167,6 +170,7 @@ public TaskToolboxFactory(
     this.taskExecutorNode = taskExecutorNode;
     this.taskActionClientFactory = taskActionClientFactory;
     this.emitter = emitter;
+    this.policyEnforcer = policyEnforcer;
     this.segmentPusher = segmentPusher;
     this.dataSegmentKiller = dataSegmentKiller;
     this.dataSegmentMover = dataSegmentMover;
@@ -223,6 +227,7 @@ public TaskToolbox build(TaskConfig config, Task task)
         .taskExecutorNode(taskExecutorNode)
         .taskActionClient(taskActionClientFactory.create(task))
         .emitter(emitter)
+        .policyEnforcer(policyEnforcer)
         .segmentPusher(segmentPusher)
         .dataSegmentKiller(dataSegmentKiller)
         .dataSegmentMover(dataSegmentMover)
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/common/TaskToolboxTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/common/TaskToolboxTest.java
index 25aa3c4a0899..f9bc25e37f88 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/common/TaskToolboxTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/common/TaskToolboxTest.java
@@ -38,6 +38,7 @@
 import org.apache.druid.query.DruidProcessingConfigTest;
 import org.apache.druid.query.QueryProcessingPool;
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.rpc.indexing.NoopOverlordClient;
 import org.apache.druid.segment.IndexIO;
 import org.apache.druid.segment.IndexMergerV9;
@@ -122,6 +123,7 @@ public void setUp() throws IOException
         new DruidNode("druid/middlemanager", "localhost", false, 8091, null, true, false),
         mockTaskActionClientFactory,
         mockEmitter,
+        NoopPolicyEnforcer.instance(),
         mockSegmentPusher,
         mockDataSegmentKiller,
         mockDataSegmentMover,
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/SingleTaskBackgroundRunnerTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/SingleTaskBackgroundRunnerTest.java
index 5590ce608ec8..c96921449da1 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/SingleTaskBackgroundRunnerTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/SingleTaskBackgroundRunnerTest.java
@@ -42,6 +42,7 @@
 import org.apache.druid.java.util.emitter.service.ServiceEmitter;
 import org.apache.druid.query.Druids;
 import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.scan.ScanResultValue;
 import org.apache.druid.query.spec.MultipleIntervalSegmentSpec;
 import org.apache.druid.rpc.indexing.NoopOverlordClient;
@@ -103,6 +104,7 @@ public void setup() throws IOException
         null,
         EasyMock.createMock(TaskActionClientFactory.class),
         emitter,
+        NoopPolicyEnforcer.instance(),
         new NoopDataSegmentPusher(),
         new NoopDataSegmentKiller(),
         new NoopDataSegmentMover(),
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLifecycleTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLifecycleTest.java
index ab090c79b90a..1675b6ebd497 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLifecycleTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLifecycleTest.java
@@ -571,6 +571,7 @@ private TaskToolboxFactory setUpTaskToolboxFactory(
         new DruidNode("druid/middlemanager", "localhost", false, 8091, null, true, false),
         tac,
         emitter,
+        NoopPolicyEnforcer.instance(),
         dataSegmentPusher,
         new LocalDataSegmentKiller(new LocalDataSegmentPusherConfig()),
         (dataSegment, targetLoadSpec) -> dataSegment,
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TestTaskToolboxFactory.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TestTaskToolboxFactory.java
index 3f3081b0e69e..c2cdedda130f 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TestTaskToolboxFactory.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TestTaskToolboxFactory.java
@@ -43,6 +43,7 @@
 import org.apache.druid.java.util.metrics.MonitorScheduler;
 import org.apache.druid.query.QueryProcessingPool;
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.rpc.indexing.NoopOverlordClient;
 import org.apache.druid.rpc.indexing.OverlordClient;
 import org.apache.druid.segment.IndexIO;
@@ -84,6 +85,7 @@ public TestTaskToolboxFactory(
         bob.taskExecutorNode,
         bob.taskActionClientFactory,
         bob.emitter,
+        bob.policyEnforcer,
         bob.segmentPusher,
         bob.dataSegmentKiller,
         bob.dataSegmentMover,
@@ -128,6 +130,7 @@ public static class Builder
     private DruidNode taskExecutorNode;
     private TaskActionClientFactory taskActionClientFactory = task -> null;
     private ServiceEmitter emitter;
+    private PolicyEnforcer policyEnforcer;
     private DataSegmentPusher segmentPusher;
     private DataSegmentKiller dataSegmentKiller;
     private DataSegmentMover dataSegmentMover;
@@ -188,6 +191,12 @@ public Builder setEmitter(ServiceEmitter emitter)
       return this;
     }
 
+    public Builder setPolicyEnforcer(PolicyEnforcer policyEnforcer)
+    {
+      this.policyEnforcer = policyEnforcer;
+      return this;
+    }
+
     public Builder setSegmentPusher(DataSegmentPusher segmentPusher)
     {
       this.segmentPusher = segmentPusher;
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTaskTestBase.java b/indexing-service/src/test/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTaskTestBase.java
index 9e82196f8117..49141f855429 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTaskTestBase.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTaskTestBase.java
@@ -99,6 +99,7 @@
 import org.apache.druid.query.aggregation.CountAggregatorFactory;
 import org.apache.druid.query.aggregation.DoubleSumAggregatorFactory;
 import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.timeseries.TimeseriesQuery;
 import org.apache.druid.query.timeseries.TimeseriesResultValue;
 import org.apache.druid.rpc.indexing.NoopOverlordClient;
@@ -675,6 +676,7 @@ public void close()
         null, // taskExecutorNode
         taskActionClientFactory,
         emitter,
+        NoopPolicyEnforcer.instance(),
         dataSegmentPusher,
         new TestDataSegmentKiller(),
         null, // DataSegmentMover
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/worker/WorkerTaskManagerTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/worker/WorkerTaskManagerTest.java
index 37839f8e0777..efd1d4046ab8 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/worker/WorkerTaskManagerTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/worker/WorkerTaskManagerTest.java
@@ -44,6 +44,7 @@
 import org.apache.druid.indexing.overlord.TestTaskRunner;
 import org.apache.druid.java.util.common.FileUtils;
 import org.apache.druid.java.util.http.client.response.StringFullResponseHolder;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.rpc.HttpResponseException;
 import org.apache.druid.rpc.indexing.OverlordClient;
 import org.apache.druid.segment.IndexIO;
@@ -134,6 +135,7 @@ private WorkerTaskManager createWorkerTaskManager()
                 null,
                 taskActionClientFactory,
                 null,
+                NoopPolicyEnforcer.instance(),
                 null,
                 null,
                 null,
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/worker/WorkerTaskMonitorTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/worker/WorkerTaskMonitorTest.java
index c8a754625358..64412e2c8e18 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/worker/WorkerTaskMonitorTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/worker/WorkerTaskMonitorTest.java
@@ -47,6 +47,7 @@
 import org.apache.druid.indexing.worker.config.WorkerConfig;
 import org.apache.druid.java.util.common.FileUtils;
 import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.rpc.indexing.NoopOverlordClient;
 import org.apache.druid.rpc.indexing.OverlordClient;
 import org.apache.druid.segment.IndexIO;
@@ -176,6 +177,7 @@ private WorkerTaskMonitor createTaskMonitor()
                 null,
                 taskActionClientFactory,
                 null,
+                NoopPolicyEnforcer.instance(),
                 null,
                 null,
                 null,
diff --git a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTest.java b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTest.java
index 72a221e9040a..0f06abe4afb9 100644
--- a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTest.java
+++ b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTest.java
@@ -29,6 +29,7 @@
 import org.apache.druid.data.input.Committer;
 import org.apache.druid.data.input.InputRow;
 import org.apache.druid.data.input.MapBasedInputRow;
+import org.apache.druid.error.DruidException;
 import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.Pair;
@@ -38,10 +39,15 @@
 import org.apache.druid.query.Druids;
 import org.apache.druid.query.Order;
 import org.apache.druid.query.QueryPlus;
+import org.apache.druid.query.RestrictedDataSource;
 import org.apache.druid.query.Result;
 import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.query.TableDataSource;
 import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
 import org.apache.druid.query.context.ResponseContext;
+import org.apache.druid.query.policy.NoRestrictionPolicy;
+import org.apache.druid.query.policy.PolicyEnforcer;
+import org.apache.druid.query.policy.RestrictAllTablesPolicyEnforcer;
 import org.apache.druid.query.scan.ScanQuery;
 import org.apache.druid.query.scan.ScanResultValue;
 import org.apache.druid.query.spec.MultipleSpecificSegmentSpec;
@@ -2222,6 +2228,43 @@ public void testQueryBySegments() throws Exception
     }
   }
 
+  @Test
+  public void testQueryThrowOnPolicyEnforcerValidationFailure() throws Exception
+  {
+    final PolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    final StreamAppenderatorTester tester = new StreamAppenderatorTester.Builder().maxRowsInMemory(2)
+                                                                                  .basePersistDirectory(temporaryFolder.newFolder())
+                                                                                  .withPolicyEnforcer(policyEnforcer)
+                                                                                  .build();
+    final Appenderator appenderator = tester.getAppenderator();
+
+    // Query on table, fail with policy enforcer
+    final TimeseriesQuery query = Druids.newTimeseriesQueryBuilder()
+                                        .dataSource(StreamAppenderatorTester.DATASOURCE)
+                                        .granularity(Granularities.DAY)
+                                        .intervals(Intervals.ONLY_ETERNITY)
+                                        .build();
+    DruidException e = Assert.assertThrows(
+        DruidException.class,
+        () -> QueryPlus.wrap(query).run(appenderator, ResponseContext.createEmpty())
+    );
+    Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
+    Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
+    Assert.assertEquals("Failed security validation with dataSource [foo]", e.getMessage());
+
+    // Query on restricted, success
+    final RestrictedDataSource restricted = RestrictedDataSource.create(
+        TableDataSource.create(StreamAppenderatorTester.DATASOURCE),
+        NoRestrictionPolicy.instance());
+    final TimeseriesQuery queryOnRestricted = Druids.newTimeseriesQueryBuilder()
+                                        .dataSource(restricted)
+                                        .granularity(Granularities.DAY)
+                                        .intervals(Intervals.ONLY_ETERNITY)
+                                        .build();
+    Assert.assertNotNull(QueryPlus.wrap(queryOnRestricted).run(appenderator, ResponseContext.createEmpty()).toList());
+
+  }
+
   private void verifySinkMetrics(StubServiceEmitter emitter, Set<String> segmentIds)
   {
     Map<String, List<StubServiceEmitter.ServiceMetricEventSnapshot>> events = emitter.getMetricEvents();
diff --git a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTester.java b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTester.java
index 71e980eaaa89..8b331b322a6e 100644
--- a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTester.java
+++ b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTester.java
@@ -49,6 +49,7 @@
 import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
 import org.apache.druid.query.expression.TestExprMacroTable;
 import org.apache.druid.query.policy.NoopPolicyEnforcer;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.query.scan.ScanQuery;
 import org.apache.druid.query.scan.ScanQueryConfig;
 import org.apache.druid.query.scan.ScanQueryEngine;
@@ -111,7 +112,8 @@ public StreamAppenderatorTester(
       final boolean skipBytesInMemoryOverheadCheck,
       final DataSegmentAnnouncer announcer,
       final CentralizedDatasourceSchemaConfig centralizedDatasourceSchemaConfig,
-      final ServiceEmitter serviceEmitter
+      final ServiceEmitter serviceEmitter,
+      final PolicyEnforcer policyEnforcer
   )
   {
     objectMapper = new DefaultObjectMapper();
@@ -245,7 +247,7 @@ ScanQuery.class, new ScanQueryRunnerFactory(
           MapCache.create(2048),
           new CacheConfig(),
           new CachePopulatorStats(),
-          NoopPolicyEnforcer.instance(),
+          policyEnforcer,
           rowIngestionMeters,
           new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
           true,
@@ -356,6 +358,7 @@ public static class Builder
     private boolean skipBytesInMemoryOverheadCheck;
     private int delayInMilli = 0;
     private ServiceEmitter serviceEmitter;
+    private PolicyEnforcer policyEnforcer = NoopPolicyEnforcer.instance();
 
     public Builder maxRowsInMemory(final int maxRowsInMemory)
     {
@@ -405,6 +408,12 @@ public Builder withServiceEmitter(ServiceEmitter serviceEmitter)
       return this;
     }
 
+    public Builder withPolicyEnforcer(PolicyEnforcer policyEnforcer)
+    {
+      this.policyEnforcer = policyEnforcer;
+      return this;
+    }
+
     public StreamAppenderatorTester build()
     {
       return new StreamAppenderatorTester(
@@ -417,7 +426,8 @@ public StreamAppenderatorTester build()
           skipBytesInMemoryOverheadCheck,
           new NoopDataSegmentAnnouncer(),
           CentralizedDatasourceSchemaConfig.create(),
-          serviceEmitter
+          serviceEmitter,
+          policyEnforcer
       );
     }
 
@@ -436,7 +446,8 @@ public StreamAppenderatorTester build(
           skipBytesInMemoryOverheadCheck,
           dataSegmentAnnouncer,
           config,
-          serviceEmitter
+          serviceEmitter,
+          policyEnforcer
       );
     }
   }
diff --git a/services/src/main/java/org/apache/druid/cli/CliPeon.java b/services/src/main/java/org/apache/druid/cli/CliPeon.java
index 3d06ad7dee3e..74ba257737fb 100644
--- a/services/src/main/java/org/apache/druid/cli/CliPeon.java
+++ b/services/src/main/java/org/apache/druid/cli/CliPeon.java
@@ -265,6 +265,7 @@ public void configure(Binder binder)
                 .setTaskFile(Paths.get(taskDirPath, "task.json").toFile())
                 .setStatusFile(Paths.get(taskDirPath, "attempt", attemptId, "status.json").toFile());
 
+            binder.bind(Properties.class).toInstance(properties);
             if (properties.getProperty("druid.indexer.runner.type", "").contains("k8s")) {
               log.info("Running peon in k8s mode");
               executorLifecycleConfig.setParentStreamDefined(false);
diff --git a/services/src/test/java/org/apache/druid/cli/CliPeonTest.java b/services/src/test/java/org/apache/druid/cli/CliPeonTest.java
index 576298921628..0743b0d62a17 100644
--- a/services/src/test/java/org/apache/druid/cli/CliPeonTest.java
+++ b/services/src/test/java/org/apache/druid/cli/CliPeonTest.java
@@ -42,6 +42,8 @@
 import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.java.util.common.granularity.AllGranularity;
 import org.apache.druid.query.DruidMetrics;
+import org.apache.druid.query.policy.PolicyEnforcer;
+import org.apache.druid.query.policy.RestrictAllTablesPolicyEnforcer;
 import org.apache.druid.segment.indexing.DataSchema;
 import org.apache.druid.storage.local.LocalTmpStorageConfig;
 import org.joda.time.Duration;
@@ -102,6 +104,23 @@ public void testCliPeonK8sANdWorkerIsK8sMode() throws IOException
     Assert.assertNotNull(runnable.makeInjector());
   }
 
+  @Test
+  public void testCliPeonPolicyEnforcerInToolbox() throws IOException
+  {
+    CliPeon runnable = new CliPeon();
+    File file = temporaryFolder.newFile("task.json");
+    FileUtils.write(file, "{\"type\":\"noop\"}", StandardCharsets.UTF_8);
+    runnable.taskAndStatusFile = ImmutableList.of(file.getParent(), "1");
+
+    Properties properties = new Properties();
+    properties.setProperty("druid.policy.enforcer.type", "restrictAllTables");
+    runnable.configure(properties);
+    runnable.configure(properties, GuiceInjectors.makeStartupInjector());
+
+    Injector secondaryInjector = runnable.makeInjector();
+    Assert.assertEquals(new RestrictAllTablesPolicyEnforcer(null), secondaryInjector.getInstance(PolicyEnforcer.class));
+  }
+
   @Test
   public void testCliPeonHeartbeatDimensions() throws IOException
   {

From 7658fa2c2acc3623532e173746caaa3afdb1cfe0 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Fri, 4 Apr 2025 12:09:05 -0700
Subject: [PATCH 79/99] revert config change in examples

---
 examples/conf/druid/auto/_common/common.runtime.properties   | 5 -----
 .../conf/druid/cluster/_common/common.runtime.properties     | 5 -----
 .../single-server/large/_common/common.runtime.properties    | 4 ----
 .../single-server/medium/_common/common.runtime.properties   | 4 ----
 .../micro-quickstart/_common/common.runtime.properties       | 4 ----
 .../nano-quickstart/_common/common.runtime.properties        | 4 ----
 .../single-server/small/_common/common.runtime.properties    | 4 ----
 .../single-server/xlarge/_common/common.runtime.properties   | 4 ----
 8 files changed, 34 deletions(-)

diff --git a/examples/conf/druid/auto/_common/common.runtime.properties b/examples/conf/druid/auto/_common/common.runtime.properties
index 13b6cfe8d18f..985a84994d14 100644
--- a/examples/conf/druid/auto/_common/common.runtime.properties
+++ b/examples/conf/druid/auto/_common/common.runtime.properties
@@ -151,8 +151,3 @@ druid.lookup.enableLookupSyncOnStartup=false
 # Expression processing config
 #
 druid.expressions.useStrictBooleans=true
-
-#
-# Row security policies
-#
-druid.policy.enforcer.type=none
diff --git a/examples/conf/druid/cluster/_common/common.runtime.properties b/examples/conf/druid/cluster/_common/common.runtime.properties
index 13b6cfe8d18f..985a84994d14 100644
--- a/examples/conf/druid/cluster/_common/common.runtime.properties
+++ b/examples/conf/druid/cluster/_common/common.runtime.properties
@@ -151,8 +151,3 @@ druid.lookup.enableLookupSyncOnStartup=false
 # Expression processing config
 #
 druid.expressions.useStrictBooleans=true
-
-#
-# Row security policies
-#
-druid.policy.enforcer.type=none
diff --git a/examples/conf/druid/single-server/large/_common/common.runtime.properties b/examples/conf/druid/single-server/large/_common/common.runtime.properties
index 13b6cfe8d18f..d27c83ca569e 100644
--- a/examples/conf/druid/single-server/large/_common/common.runtime.properties
+++ b/examples/conf/druid/single-server/large/_common/common.runtime.properties
@@ -152,7 +152,3 @@ druid.lookup.enableLookupSyncOnStartup=false
 #
 druid.expressions.useStrictBooleans=true
 
-#
-# Row security policies
-#
-druid.policy.enforcer.type=none
diff --git a/examples/conf/druid/single-server/medium/_common/common.runtime.properties b/examples/conf/druid/single-server/medium/_common/common.runtime.properties
index 13b6cfe8d18f..d27c83ca569e 100644
--- a/examples/conf/druid/single-server/medium/_common/common.runtime.properties
+++ b/examples/conf/druid/single-server/medium/_common/common.runtime.properties
@@ -152,7 +152,3 @@ druid.lookup.enableLookupSyncOnStartup=false
 #
 druid.expressions.useStrictBooleans=true
 
-#
-# Row security policies
-#
-druid.policy.enforcer.type=none
diff --git a/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties b/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties
index 13b6cfe8d18f..d27c83ca569e 100644
--- a/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties
+++ b/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties
@@ -152,7 +152,3 @@ druid.lookup.enableLookupSyncOnStartup=false
 #
 druid.expressions.useStrictBooleans=true
 
-#
-# Row security policies
-#
-druid.policy.enforcer.type=none
diff --git a/examples/conf/druid/single-server/nano-quickstart/_common/common.runtime.properties b/examples/conf/druid/single-server/nano-quickstart/_common/common.runtime.properties
index 13b6cfe8d18f..d27c83ca569e 100644
--- a/examples/conf/druid/single-server/nano-quickstart/_common/common.runtime.properties
+++ b/examples/conf/druid/single-server/nano-quickstart/_common/common.runtime.properties
@@ -152,7 +152,3 @@ druid.lookup.enableLookupSyncOnStartup=false
 #
 druid.expressions.useStrictBooleans=true
 
-#
-# Row security policies
-#
-druid.policy.enforcer.type=none
diff --git a/examples/conf/druid/single-server/small/_common/common.runtime.properties b/examples/conf/druid/single-server/small/_common/common.runtime.properties
index 13b6cfe8d18f..d27c83ca569e 100644
--- a/examples/conf/druid/single-server/small/_common/common.runtime.properties
+++ b/examples/conf/druid/single-server/small/_common/common.runtime.properties
@@ -152,7 +152,3 @@ druid.lookup.enableLookupSyncOnStartup=false
 #
 druid.expressions.useStrictBooleans=true
 
-#
-# Row security policies
-#
-druid.policy.enforcer.type=none
diff --git a/examples/conf/druid/single-server/xlarge/_common/common.runtime.properties b/examples/conf/druid/single-server/xlarge/_common/common.runtime.properties
index 13b6cfe8d18f..d27c83ca569e 100644
--- a/examples/conf/druid/single-server/xlarge/_common/common.runtime.properties
+++ b/examples/conf/druid/single-server/xlarge/_common/common.runtime.properties
@@ -152,7 +152,3 @@ druid.lookup.enableLookupSyncOnStartup=false
 #
 druid.expressions.useStrictBooleans=true
 
-#
-# Row security policies
-#
-druid.policy.enforcer.type=none

From e2aa0d2863f96cc8b763e6a916c867d57f41bfdc Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Fri, 4 Apr 2025 12:35:22 -0700
Subject: [PATCH 80/99] revert config change in integration test config

---
 integration-tests/docker/environment-configs/common      | 1 -
 integration-tests/docker/environment-configs/common-ldap | 1 -
 2 files changed, 2 deletions(-)

diff --git a/integration-tests/docker/environment-configs/common b/integration-tests/docker/environment-configs/common
index 3d35ff022211..e99ee2acd43c 100644
--- a/integration-tests/docker/environment-configs/common
+++ b/integration-tests/docker/environment-configs/common
@@ -39,7 +39,6 @@ druid_auth_authenticatorChain=["basic"]
 druid_auth_authorizer_basic_type=basic
 druid_auth_authorizers=["basic"]
 druid_auth_authorizeQueryContextParams=true
-druid_policy_enforcer_type=none
 druid_client_https_certAlias=druid
 druid_client_https_keyManagerPassword=druid123
 druid_client_https_keyStorePassword=druid123
diff --git a/integration-tests/docker/environment-configs/common-ldap b/integration-tests/docker/environment-configs/common-ldap
index 9a022b19c79b..fae9b18c341a 100644
--- a/integration-tests/docker/environment-configs/common-ldap
+++ b/integration-tests/docker/environment-configs/common-ldap
@@ -49,7 +49,6 @@ druid_auth_authorizer_ldapauth_initialAdminRole=admin
 druid_auth_authorizer_ldapauth_roleProvider_type=ldap
 druid_auth_authorizers=["ldapauth"]
 druid_auth_authorizeQueryContextParams=true
-druid_policy_enforcer_type=none
 druid_client_https_certAlias=druid
 druid_client_https_keyManagerPassword=druid123
 druid_client_https_keyStorePassword=druid123

From 1e53d821cfc8c00755296ce4d7054e88ccf7747e Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Mon, 7 Apr 2025 08:11:31 -0700
Subject: [PATCH 81/99] more tests in msq

---
 extensions-core/multi-stage-query/pom.xml     |   4 +
 .../msq/dart/worker/DartFrameContext.java     |   2 +-
 .../msq/dart/worker/DartWorkerContext.java    |  10 +
 .../dart/worker/DartWorkerFactoryImpl.java    |   5 +
 .../apache/druid/msq/exec/WorkerContext.java  |   3 +
 .../msq/indexing/IndexerFrameContext.java     |   2 +-
 .../msq/indexing/IndexerWorkerContext.java    |   7 +
 .../msq/querykit/BaseLeafFrameProcessor.java  |  35 +-
 .../msq/querykit/FrameProcessorTestBase.java  |   2 +-
 .../scan/ScanQueryFrameProcessorTest.java     | 112 +++++
 .../druid/msq/sql/MSQTaskQueryMakerTest.java  | 383 ++++++++++++++++++
 .../druid/msq/test/MSQTestWorkerContext.java  |   8 +-
 .../org/apache/druid/segment/Segment.java     |  11 -
 .../druid/segment/SegmentReference.java       |  13 +
 .../druid/segment/InlineSegmentWrangler.java  |   2 +-
 .../sql/calcite/BaseCalciteQueryTest.java     |   2 +-
 16 files changed, 576 insertions(+), 25 deletions(-)
 create mode 100644 extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java

diff --git a/extensions-core/multi-stage-query/pom.xml b/extensions-core/multi-stage-query/pom.xml
index edc5d90d3b7b..bc26993c072b 100644
--- a/extensions-core/multi-stage-query/pom.xml
+++ b/extensions-core/multi-stage-query/pom.xml
@@ -334,6 +334,10 @@
             <version>${project.parent.version}</version>
             <scope>test</scope>
         </dependency>
+      <dependency>
+        <groupId>com.google.inject.extensions</groupId>
+        <artifactId>guice-testlib</artifactId>
+      </dependency>
     </dependencies>
 
     <build>
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartFrameContext.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartFrameContext.java
index 09d69bc3e679..130a639396e5 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartFrameContext.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartFrameContext.java
@@ -82,7 +82,7 @@ public DartFrameContext(
   @Override
   public PolicyEnforcer policyEnforcer()
   {
-    return workerContext.injector().getInstance(PolicyEnforcer.class);
+    return workerContext.policyEnforcer();
   }
 
   @Override
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerContext.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerContext.java
index 05cbf210f897..530a4ec3e2e6 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerContext.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerContext.java
@@ -44,6 +44,7 @@
 import org.apache.druid.query.DruidProcessingConfig;
 import org.apache.druid.query.QueryContext;
 import org.apache.druid.query.groupby.GroupingEngine;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.SegmentWrangler;
 import org.apache.druid.server.DruidNode;
 import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
@@ -61,6 +62,7 @@ public class DartWorkerContext implements WorkerContext
   private final WorkerId workerId;
   private final DruidNode selfNode;
   private final ObjectMapper jsonMapper;
+  private final PolicyEnforcer policyEnforcer;
   private final Injector injector;
   private final DartWorkerClient workerClient;
   private final DruidProcessingConfig processingConfig;
@@ -84,6 +86,7 @@ public class DartWorkerContext implements WorkerContext
       final String controllerHost,
       final DruidNode selfNode,
       final ObjectMapper jsonMapper,
+      final PolicyEnforcer policyEnforcer,
       final Injector injector,
       final DartWorkerClient workerClient,
       final DruidProcessingConfig processingConfig,
@@ -102,6 +105,7 @@ public class DartWorkerContext implements WorkerContext
     this.workerId = WorkerId.fromDruidNode(selfNode, queryId);
     this.selfNode = selfNode;
     this.jsonMapper = jsonMapper;
+    this.policyEnforcer = policyEnforcer;
     this.injector = injector;
     this.workerClient = workerClient;
     this.processingConfig = processingConfig;
@@ -133,6 +137,12 @@ public ObjectMapper jsonMapper()
     return jsonMapper;
   }
 
+  @Override
+  public PolicyEnforcer policyEnforcer()
+  {
+    return policyEnforcer;
+  }
+
   @Override
   public Injector injector()
   {
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerFactoryImpl.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerFactoryImpl.java
index 1960924b4b67..06b9226bc37e 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerFactoryImpl.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/dart/worker/DartWorkerFactoryImpl.java
@@ -38,6 +38,7 @@
 import org.apache.druid.query.DruidProcessingConfig;
 import org.apache.druid.query.QueryContext;
 import org.apache.druid.query.groupby.GroupingEngine;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.rpc.ServiceClientFactory;
 import org.apache.druid.segment.SegmentWrangler;
 import org.apache.druid.server.DruidNode;
@@ -52,6 +53,7 @@ public class DartWorkerFactoryImpl implements DartWorkerFactory
   private final DruidNode selfNode;
   private final ObjectMapper jsonMapper;
   private final ObjectMapper smileMapper;
+  private final PolicyEnforcer policyEnforcer;
   private final Injector injector;
   private final ServiceClientFactory serviceClientFactory;
   private final DruidProcessingConfig processingConfig;
@@ -67,6 +69,7 @@ public DartWorkerFactoryImpl(
       @Self DruidNode selfNode,
       @Json ObjectMapper jsonMapper,
       @Smile ObjectMapper smileMapper,
+      PolicyEnforcer policyEnforcer,
       Injector injector,
       @EscalatedGlobal ServiceClientFactory serviceClientFactory,
       DruidProcessingConfig processingConfig,
@@ -81,6 +84,7 @@ public DartWorkerFactoryImpl(
     this.selfNode = selfNode;
     this.jsonMapper = jsonMapper;
     this.smileMapper = smileMapper;
+    this.policyEnforcer = policyEnforcer;
     this.injector = injector;
     this.serviceClientFactory = serviceClientFactory;
     this.processingConfig = processingConfig;
@@ -100,6 +104,7 @@ public Worker build(String queryId, String controllerHost, File tempDir, QueryCo
         controllerHost,
         selfNode,
         jsonMapper,
+        policyEnforcer,
         injector,
         new DartWorkerClientImpl(queryId, serviceClientFactory, smileMapper, null),
         processingConfig,
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/exec/WorkerContext.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/exec/WorkerContext.java
index 90082fcf0dd0..50cbe781dc7b 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/exec/WorkerContext.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/exec/WorkerContext.java
@@ -27,6 +27,7 @@
 import org.apache.druid.msq.kernel.FrameProcessorFactory;
 import org.apache.druid.msq.kernel.WorkOrder;
 import org.apache.druid.msq.util.MultiStageQueryContext;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.server.DruidNode;
 
 import java.io.File;
@@ -51,6 +52,8 @@ public interface WorkerContext
 
   ObjectMapper jsonMapper();
 
+  PolicyEnforcer policyEnforcer();
+
   // Using an Injector directly because tasks do not have a way to provide their own Guice modules.
   Injector injector();
 
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/indexing/IndexerFrameContext.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/indexing/IndexerFrameContext.java
index 293034602584..f7e019c9aca7 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/indexing/IndexerFrameContext.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/indexing/IndexerFrameContext.java
@@ -77,7 +77,7 @@ public IndexerFrameContext(
   @Override
   public PolicyEnforcer policyEnforcer()
   {
-    return context.injector().getInstance(PolicyEnforcer.class);
+    return context.policyEnforcer();
   }
 
   @Override
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/indexing/IndexerWorkerContext.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/indexing/IndexerWorkerContext.java
index a26eded43221..1175f6ed2071 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/indexing/IndexerWorkerContext.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/indexing/IndexerWorkerContext.java
@@ -52,6 +52,7 @@
 import org.apache.druid.msq.util.MultiStageQueryContext;
 import org.apache.druid.query.QueryContext;
 import org.apache.druid.query.QueryToolChestWarehouse;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.rpc.ServiceClientFactory;
 import org.apache.druid.rpc.ServiceLocations;
 import org.apache.druid.rpc.ServiceLocator;
@@ -191,6 +192,12 @@ public ObjectMapper jsonMapper()
     return toolbox.getJsonMapper();
   }
 
+  @Override
+  public PolicyEnforcer policyEnforcer()
+  {
+    return toolbox.getPolicyEnforcer();
+  }
+
   @Override
   public Injector injector()
   {
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessor.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessor.java
index 98e4dd0dfea2..767965dfce68 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessor.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessor.java
@@ -32,9 +32,13 @@
 import org.apache.druid.java.util.common.Unit;
 import org.apache.druid.msq.exec.DataServerQueryHandler;
 import org.apache.druid.msq.input.ReadableInput;
+import org.apache.druid.msq.input.external.ExternalInputSliceReader;
+import org.apache.druid.msq.input.inline.InlineInputSliceReader;
 import org.apache.druid.msq.input.table.SegmentWithDescriptor;
 import org.apache.druid.msq.input.table.SegmentsInputSlice;
+import org.apache.druid.query.lookup.LookupSegment;
 import org.apache.druid.query.policy.PolicyEnforcer;
+import org.apache.druid.segment.InlineSegmentWrangler;
 import org.apache.druid.segment.ReferenceCountingSegment;
 import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.SegmentReference;
@@ -139,16 +143,31 @@ protected abstract ReturnOrAwait<Unit> runWithInputChannel(
   protected SegmentReference mapSegment(final Segment segment)
   {
     SegmentReference mappedSegment = segmentMapFn.apply(ReferenceCountingSegment.wrapRootGenerationSegment(segment));
+    if (segment instanceof LookupSegment) {
+      return mappedSegment;
+    }
+    return validateMappedSegment(mappedSegment);
+  }
+
+  private SegmentReference validateMappedSegment(SegmentReference mappedSegment)
+  {
+    switch (mappedSegment.getId().getDataSource()) {
+      case InlineSegmentWrangler.SEGMENT_ID:
+      case InlineInputSliceReader.SEGMENT_ID:
+      case ExternalInputSliceReader.SEGMENT_ID:
+        return mappedSegment;
+      default:
+        // continue
+    }
     if (mappedSegment.validate(policyEnforcer)) {
       return mappedSegment;
-    } else {
-      throw DruidException.forPersona(DruidException.Persona.OPERATOR)
-                          .ofCategory(DruidException.Category.FORBIDDEN)
-                          .build(
-                              "Failed security validation with segment [%s] type [%s]",
-                              segment.getId(),
-                              segment.getClass()
-                          );
     }
+    throw DruidException.forPersona(DruidException.Persona.OPERATOR)
+                        .ofCategory(DruidException.Category.FORBIDDEN)
+                        .build(
+                            "Failed security validation with segment [%s] type [%s]",
+                            mappedSegment.getId(),
+                            mappedSegment.getClass()
+                        );
   }
 }
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/FrameProcessorTestBase.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/FrameProcessorTestBase.java
index cde2b0ea4e9d..6ae3e7ec4efc 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/FrameProcessorTestBase.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/FrameProcessorTestBase.java
@@ -52,7 +52,7 @@ public class FrameProcessorTestBase extends InitializedNullHandlingTest
   protected FrameProcessorExecutor exec;
 
   @Before
-  public void setUp()
+  public void setUp() throws Exception
   {
     innerExec = MoreExecutors.listeningDecorator(Execs.singleThreaded("test-exec"));
     exec = new FrameProcessorExecutor(innerExec);
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorTest.java
index bcfe76af0052..c0dae92f753d 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorTest.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorTest.java
@@ -47,15 +47,23 @@
 import org.apache.druid.msq.kernel.StagePartition;
 import org.apache.druid.msq.querykit.FrameProcessorTestBase;
 import org.apache.druid.msq.test.LimitedFrameWriterFactory;
+import org.apache.druid.query.DataSource;
 import org.apache.druid.query.Druids;
+import org.apache.druid.query.RestrictedDataSource;
+import org.apache.druid.query.TableDataSource;
+import org.apache.druid.query.policy.NoRestrictionPolicy;
 import org.apache.druid.query.policy.NoopPolicyEnforcer;
+import org.apache.druid.query.policy.PolicyEnforcer;
+import org.apache.druid.query.policy.RestrictAllTablesPolicyEnforcer;
 import org.apache.druid.query.scan.ScanQuery;
 import org.apache.druid.query.spec.MultipleIntervalSegmentSpec;
+import org.apache.druid.query.spec.QuerySegmentSpec;
 import org.apache.druid.segment.CompleteSegment;
 import org.apache.druid.segment.CursorFactory;
 import org.apache.druid.segment.QueryableIndex;
 import org.apache.druid.segment.QueryableIndexCursorFactory;
 import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.SegmentReference;
 import org.apache.druid.segment.TestIndex;
 import org.apache.druid.segment.column.RowSignature;
 import org.apache.druid.segment.incremental.IncrementalIndexCursorFactory;
@@ -63,6 +71,7 @@
 import org.hamcrest.CoreMatchers;
 import org.hamcrest.MatcherAssert;
 import org.junit.Assert;
+import org.junit.Before;
 import org.junit.Test;
 import org.junit.internal.matchers.ThrowableMessageMatcher;
 
@@ -73,6 +82,33 @@
 
 public class ScanQueryFrameProcessorTest extends FrameProcessorTestBase
 {
+  private CursorFactory cursorFactory;
+  private ReadableInput baseInput;
+  private FrameWriterFactory frameWriterFactory;
+  private BlockingQueueFrameChannel outputChannel;
+
+  @Override
+  @Before
+  public void setUp() throws Exception
+  {
+    final QueryableIndex queryableIndex = TestIndex.getMMappedTestIndex();
+    cursorFactory = new QueryableIndexCursorFactory(queryableIndex);
+    baseInput = makeChannelFromCursorFactory(cursorFactory, ImmutableList.of(), 1000);
+
+    // Limit output frames to 1 row to ensure we test edge cases
+    frameWriterFactory = new LimitedFrameWriterFactory(
+        FrameWriters.makeRowBasedFrameWriterFactory(
+            new SingleMemoryAllocatorFactory(HeapMemoryAllocator.unlimited()),
+            new QueryableIndexCursorFactory(queryableIndex).getRowSignature(),
+            Collections.emptyList(),
+            false
+        ),
+        1
+    );
+    outputChannel = BlockingQueueFrameChannel.minimal();
+
+    super.setUp();
+  }
 
   @Test
   public void test_runWithSegments() throws Exception
@@ -258,4 +294,80 @@ public void close()
             + "2011-01-02T00:00:00.000Z/2021-01-01T00:00:00.000Z]]"))
     );
   }
+
+  @Test
+  public void test_runWithPolicyEnforcerThrowsOnValidationFailure() throws Exception
+  {
+    // Arrange
+    QuerySegmentSpec querySegmentSpec = new MultipleIntervalSegmentSpec(Intervals.ONLY_ETERNITY);
+    DataSource dataSource = TableDataSource.create("test");
+    ScanQuery query =
+        Druids.newScanQueryBuilder()
+              .dataSource(dataSource)
+              .intervals(querySegmentSpec)
+              .columns(cursorFactory.getRowSignature().getColumnNames())
+              .build();
+    Function<SegmentReference, SegmentReference> mapFn = dataSource.createSegmentMapFunction(query);
+
+    PolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    final ScanQueryFrameProcessor processor = new ScanQueryFrameProcessor(
+        query,
+        null,
+        new DefaultObjectMapper(),
+        policyEnforcer,
+        baseInput,
+        mapFn,
+        ResourceHolder.fromCloseable(outputChannel.writable()),
+        new ReferenceCountingResourceHolder<>(frameWriterFactory, () -> {
+        })
+    );
+    // Act
+    exec.runFully(processor, null);
+    final Sequence<List<Object>> rowsFromProcessor = FrameTestUtil.readRowsFromFrameChannel(
+        outputChannel.readable(),
+        FrameReader.create(cursorFactory.getRowSignature())
+    );
+    // Assert
+    Exception e = Assert.assertThrows(Exception.class, () -> rowsFromProcessor.toList());
+    Assert.assertTrue(e.getCause().getMessage().contains("Failed security validation"));
+  }
+
+  @Test
+  public void test_runWithPolicyEnforcerPassedValidation() throws Exception
+  {
+    // Arrange
+    QuerySegmentSpec querySegmentSpec = new MultipleIntervalSegmentSpec(Intervals.ONLY_ETERNITY);
+    DataSource dataSource = RestrictedDataSource.create(TableDataSource.create("test"), NoRestrictionPolicy.instance());
+    ScanQuery query =
+        Druids.newScanQueryBuilder()
+              .dataSource(dataSource)
+              .intervals(querySegmentSpec)
+              .columns(cursorFactory.getRowSignature().getColumnNames())
+              .build();
+    Function<SegmentReference, SegmentReference> mapFn = dataSource.createSegmentMapFunction(query);
+
+    PolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    final ScanQueryFrameProcessor processor = new ScanQueryFrameProcessor(
+        query,
+        null,
+        new DefaultObjectMapper(),
+        policyEnforcer,
+        baseInput,
+        mapFn,
+        ResourceHolder.fromCloseable(outputChannel.writable()),
+        new ReferenceCountingResourceHolder<>(frameWriterFactory, () -> {
+        })
+    );
+    // Act
+    exec.runFully(processor, null);
+    final Sequence<List<Object>> rowsFromProcessorOnRestricted = FrameTestUtil.readRowsFromFrameChannel(
+        outputChannel.readable(),
+        FrameReader.create(cursorFactory.getRowSignature())
+    );
+    // Assert
+    FrameTestUtil.assertRowsEqual(
+        FrameTestUtil.readRowsFromCursorFactory(cursorFactory, cursorFactory.getRowSignature(), false),
+        rowsFromProcessorOnRestricted
+    );
+  }
 }
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
new file mode 100644
index 000000000000..2c85067582c2
--- /dev/null
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
@@ -0,0 +1,383 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.msq.sql;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.collect.ImmutableList;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import com.google.inject.Module;
+import com.google.inject.testing.fieldbinder.Bind;
+import com.google.inject.testing.fieldbinder.BoundFieldModule;
+import com.google.inject.util.Modules;
+import org.apache.druid.collections.ReferenceCountingResourceHolder;
+import org.apache.druid.guice.ConfigModule;
+import org.apache.druid.guice.DruidGuiceExtensions;
+import org.apache.druid.guice.DruidSecondaryModule;
+import org.apache.druid.guice.LifecycleModule;
+import org.apache.druid.guice.SegmentWranglerModule;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.msq.exec.DataServerQueryHandlerFactory;
+import org.apache.druid.msq.indexing.MSQControllerTask;
+import org.apache.druid.msq.indexing.MSQSpec;
+import org.apache.druid.msq.indexing.MSQTuningConfig;
+import org.apache.druid.msq.indexing.destination.TaskReportMSQDestination;
+import org.apache.druid.msq.indexing.error.MSQErrorReport;
+import org.apache.druid.msq.indexing.report.MSQTaskReport;
+import org.apache.druid.msq.indexing.report.MSQTaskReportPayload;
+import org.apache.druid.msq.querykit.DataSegmentProvider;
+import org.apache.druid.msq.test.MSQTestBase;
+import org.apache.druid.msq.test.MSQTestOverlordServiceClient;
+import org.apache.druid.msq.test.MSQTestTaskActionClient;
+import org.apache.druid.query.Druids;
+import org.apache.druid.query.ForwardingQueryProcessingPool;
+import org.apache.druid.query.InlineDataSource;
+import org.apache.druid.query.LookupDataSource;
+import org.apache.druid.query.OrderBy;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryProcessingPool;
+import org.apache.druid.query.RestrictedDataSource;
+import org.apache.druid.query.TableDataSource;
+import org.apache.druid.query.filter.EqualityFilter;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
+import org.apache.druid.query.policy.PolicyEnforcer;
+import org.apache.druid.query.policy.RestrictAllTablesPolicyEnforcer;
+import org.apache.druid.query.policy.RowFilterPolicy;
+import org.apache.druid.query.scan.ScanQuery;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.TestHelper;
+import org.apache.druid.segment.column.ColumnConfig;
+import org.apache.druid.segment.column.ColumnType;
+import org.apache.druid.segment.column.RowSignature;
+import org.apache.druid.server.QueryStackTests;
+import org.apache.druid.server.SpecificSegmentsQuerySegmentWalker;
+import org.apache.druid.sql.calcite.planner.ColumnMappings;
+import org.apache.druid.sql.calcite.util.CalciteTests;
+import org.apache.druid.sql.calcite.util.LookylooModule;
+import org.apache.druid.sql.calcite.util.TestDataBuilder;
+import org.apache.druid.timeline.SegmentId;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.function.Supplier;
+
+import static org.apache.druid.sql.calcite.BaseCalciteQueryTest.assertResultsEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.Mockito.when;
+
+public class MSQTaskQueryMakerTest
+{
+  private static final Closer CLOSER = Closer.create();
+
+  @Rule
+  public MockitoRule mockitoRule = MockitoJUnit.rule();
+
+  @Bind
+  private SpecificSegmentsQuerySegmentWalker walker;
+  @Bind
+  @Mock
+  private DataSegmentProvider dataSegmentProviderMock;
+  @Bind
+  private ObjectMapper objectMapper;
+  @Bind
+  private IndexIO indexIO;
+  @Bind
+  private QueryProcessingPool queryProcessingPool;
+  @Bind
+  @Nullable
+  private DataServerQueryHandlerFactory dataServerQueryHandlerFactory;
+  @Bind(lazy = true)
+  private PolicyEnforcer policyEnforcer;
+
+  private MSQTestOverlordServiceClient overlordClient;
+
+  @Before
+  public void setUp() throws Exception
+  {
+    walker = TestDataBuilder.addDataSetsToWalker(
+        FileUtils.getTempDir().toFile(),
+        SpecificSegmentsQuerySegmentWalker.createWalker(QueryStackTests.createQueryRunnerFactoryConglomerate(CLOSER))
+    );
+    when(dataSegmentProviderMock.fetchSegment(
+        any(),
+        any(),
+        anyBoolean()
+    )).thenAnswer(invocation -> (Supplier<?>) () -> {
+      SegmentId segmentId = (SegmentId) invocation.getArguments()[0];
+      return ReferenceCountingResourceHolder.fromCloseable(walker.getSegment(segmentId));
+    });
+
+    objectMapper = TestHelper.makeJsonMapper();
+    indexIO = new IndexIO(objectMapper, ColumnConfig.DEFAULT);
+    queryProcessingPool = new ForwardingQueryProcessingPool(Execs.singleThreaded("Test-runner-processing-pool"));
+    policyEnforcer = NoopPolicyEnforcer.instance();
+    Module defaultModule = Modules.combine(
+        new DruidGuiceExtensions(),
+        new LifecycleModule(),
+        new ConfigModule(),
+        new SegmentWranglerModule(),
+        new LookylooModule()
+    );
+    Injector injector = Guice.createInjector(defaultModule, BoundFieldModule.of(this));
+    DruidSecondaryModule.setupJackson(injector, objectMapper);
+
+    overlordClient = new MSQTestOverlordServiceClient(
+        objectMapper,
+        injector,
+        new MSQTestTaskActionClient(objectMapper, injector),
+        MSQTestBase.makeTestWorkerMemoryParameters(),
+        new ArrayList<>()
+    );
+  }
+
+  @Test
+  public void testSimpleScanQuery() throws Exception
+  {
+    // Arrange
+    ScanQuery query = new Druids.ScanQueryBuilder()
+        .resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
+        .eternityInterval()
+        .dataSource(CalciteTests.DATASOURCE1)
+        .columns(ImmutableList.of("cnt", "dim1"))
+        .columnTypes(ColumnType.LONG, ColumnType.STRING)
+        .build();
+    RowSignature resultSignature = RowSignature.builder()
+                                               .add("cnt", ColumnType.LONG)
+                                               .add("dim1", ColumnType.STRING)
+                                               .build();
+    String controllerTaskId = "scan_query";
+    MSQControllerTask controllerTask = new MSQControllerTask(
+        controllerTaskId,
+        MSQSpec.builder()
+               .query(query)
+               .columnMappings(ColumnMappings.identity(resultSignature))
+               .tuningConfig(MSQTuningConfig.defaultConfig())
+               .destination(TaskReportMSQDestination.INSTANCE)
+               .build(),
+        "select cnt, dim1 from foo",
+        null,
+        null,
+        null,
+        null,
+        null,
+        null
+    );
+    // Act
+    overlordClient.runTask(controllerTaskId, controllerTask).get();
+    MSQTaskReportPayload payload = (MSQTaskReportPayload) overlordClient.getReportForTask(controllerTaskId)
+                                                                        .get(MSQTaskReport.REPORT_KEY)
+                                                                        .getPayload();
+    // Assert
+    Assert.assertTrue(payload.getStatus().getStatus().isSuccess());
+    ImmutableList<Object[]> expectedResults = ImmutableList.of(
+        new Object[]{1L, ""},
+        new Object[]{1L, "10.1"},
+        new Object[]{1L, "2"},
+        new Object[]{1L, "1"},
+        new Object[]{1L, "def"},
+        new Object[]{1L, "abc"}
+    );
+    assertResultsEquals("select cnt, dim1 from foo", expectedResults, payload.getResults().getResults());
+  }
+
+  @Test
+  public void testScanQueryFailWithPolicyValidation() throws Exception
+  {
+    // Arrange
+    policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    ScanQuery query = new Druids.ScanQueryBuilder()
+        .resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
+        .eternityInterval()
+        .dataSource(CalciteTests.DATASOURCE1)
+        .columns(ImmutableList.of("cnt", "dim1"))
+        .columnTypes(ColumnType.LONG, ColumnType.STRING)
+        .build();
+    RowSignature resultSignature = RowSignature.builder()
+                                               .add("cnt", ColumnType.LONG)
+                                               .add("dim1", ColumnType.STRING)
+                                               .build();
+    String controllerTaskId = "scan_query";
+    MSQControllerTask controllerTask = buildMSQControllerTask(
+        controllerTaskId,
+        query,
+        resultSignature,
+        "select cnt, dim1 from foo"
+    );
+    // Act
+    overlordClient.runTask(controllerTaskId, controllerTask).get();
+    MSQTaskReportPayload payload = (MSQTaskReportPayload) overlordClient.getReportForTask(controllerTaskId)
+                                                                        .get(MSQTaskReport.REPORT_KEY)
+                                                                        .getPayload();
+    // Assert
+    Assert.assertTrue(payload.getStatus().getStatus().isFailure());
+    MSQErrorReport errorReport = payload.getStatus().getErrorReport();
+    Assert.assertTrue(errorReport.getFault().getErrorMessage().contains("Failed security validation"));
+  }
+
+  @Test
+  public void testScanQueryPassedPolicyValidation() throws Exception
+  {
+    // Arrange
+    policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    RestrictedDataSource restrictedDataSource = RestrictedDataSource.create(
+        TableDataSource.create(CalciteTests.DATASOURCE1),
+        RowFilterPolicy.from(new EqualityFilter(
+            "dim1",
+            ColumnType.STRING,
+            "abc",
+            null
+        ))
+    );
+    ScanQuery query = new Druids.ScanQueryBuilder()
+        .resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
+        .eternityInterval()
+        .dataSource(restrictedDataSource)
+        .columns(ImmutableList.of("cnt", "dim1"))
+        .columnTypes(ColumnType.LONG, ColumnType.STRING)
+        .build();
+    RowSignature resultSignature = RowSignature.builder()
+                                               .add("cnt", ColumnType.LONG)
+                                               .add("dim1", ColumnType.STRING)
+                                               .build();
+    String controllerTaskId = "scan_query";
+    MSQControllerTask controllerTask = buildMSQControllerTask(
+        controllerTaskId,
+        query,
+        resultSignature,
+        "select cnt, dim1 from foo (with restriction)"
+    );
+    // Act
+    overlordClient.runTask(controllerTaskId, controllerTask).get();
+    MSQTaskReportPayload payload = (MSQTaskReportPayload) overlordClient.getReportForTask(controllerTaskId)
+                                                                        .get(MSQTaskReport.REPORT_KEY)
+                                                                        .getPayload();
+    // Assert
+    Assert.assertTrue(payload.getStatus().getStatus().isSuccess());
+    ImmutableList<Object[]> expectedResults = ImmutableList.of(new Object[]{1L, "abc"});
+    assertResultsEquals(
+        "select cnt, dim1 from foo (with restriction)",
+        expectedResults,
+        payload.getResults().getResults()
+    );
+  }
+
+  @Test
+  public void testInlineDataSourcePassedPolicyValidation() throws Exception
+  {
+    // Arrange
+    policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    RowSignature resultSignature = RowSignature.builder()
+                                               .add("EXPR$0", ColumnType.LONG)
+                                               .build();
+    InlineDataSource inlineDataSource = InlineDataSource.fromIterable(
+        ImmutableList.of(new Object[]{2L}),
+        resultSignature
+    );
+    ScanQuery query = Druids.newScanQueryBuilder()
+                            .dataSource(inlineDataSource)
+                            .eternityInterval()
+                            .columns("EXPR$0")
+                            .columnTypes(ColumnType.LONG)
+                            .build();
+    String controllerTaskId = "scan_query";
+    MSQControllerTask controllerTask = buildMSQControllerTask(controllerTaskId, query, resultSignature, "select 1 + 1");
+    // Act
+    overlordClient.runTask(controllerTaskId, controllerTask).get();
+    MSQTaskReportPayload payload = (MSQTaskReportPayload) overlordClient.getReportForTask(controllerTaskId)
+                                                                        .get(MSQTaskReport.REPORT_KEY)
+                                                                        .getPayload();
+    // Assert
+    Assert.assertTrue(payload.getStatus().getStatus().isSuccess());
+    ImmutableList<Object[]> expectedResults = ImmutableList.of(new Object[]{2L});
+    assertResultsEquals("select 1 + 1", expectedResults, payload.getResults().getResults());
+  }
+
+  @Test
+  public void testLookupDataSourcePassedPolicyValidation() throws Exception
+  {
+    // Arrange
+    policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    final RowSignature rowSignature = RowSignature.builder().add("v", ColumnType.STRING).build();
+    ScanQuery query = Druids.newScanQueryBuilder()
+                            .resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
+                            .eternityInterval()
+                            .dataSource(new LookupDataSource("lookyloo"))
+                            .columns(ImmutableList.of("v"))
+                            .columnTypes(ColumnType.STRING)
+                            .orderBy(ImmutableList.of(OrderBy.ascending("v")))
+                            .build();
+    String controllerTaskId = "scan_query";
+    MSQControllerTask controllerTask = buildMSQControllerTask(
+        controllerTaskId,
+        query,
+        rowSignature,
+        "select v from lookyloo"
+    );
+    // Act
+    overlordClient.runTask(controllerTaskId, controllerTask).get();
+    MSQTaskReportPayload payload = (MSQTaskReportPayload) overlordClient.getReportForTask(controllerTaskId)
+                                                                        .get(MSQTaskReport.REPORT_KEY)
+                                                                        .getPayload();
+    // Assert
+    Assert.assertTrue(payload.getStatus().getStatus().isSuccess());
+    ImmutableList<Object[]> expectedResults = ImmutableList.of(
+        new Object[]{"mysteryvalue"},
+        new Object[]{"x6"},
+        new Object[]{"xa"},
+        new Object[]{"xabc"}
+    );
+    assertResultsEquals("select v from lookyloo", expectedResults, payload.getResults().getResults());
+  }
+
+  private static MSQControllerTask buildMSQControllerTask(
+      String controllerTaskId,
+      Query<?> query,
+      RowSignature resultSignature,
+      String sql
+  )
+  {
+    return new MSQControllerTask(
+        controllerTaskId,
+        MSQSpec.builder()
+               .query(query)
+               .columnMappings(ColumnMappings.identity(resultSignature))
+               .tuningConfig(MSQTuningConfig.defaultConfig())
+               .destination(TaskReportMSQDestination.INSTANCE)
+               .build(),
+        sql,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null
+    );
+  }
+}
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestWorkerContext.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestWorkerContext.java
index 2ee604beb0cb..865457d4062b 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestWorkerContext.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestWorkerContext.java
@@ -95,6 +95,12 @@ public ObjectMapper jsonMapper()
     return mapper;
   }
 
+  @Override
+  public PolicyEnforcer policyEnforcer()
+  {
+    return injector.getInstance(PolicyEnforcer.class);
+  }
+
   @Override
   public Injector injector()
   {
@@ -179,7 +185,7 @@ public FrameContextImpl(File tempDir)
     @Override
     public PolicyEnforcer policyEnforcer()
     {
-      return injector.getInstance(PolicyEnforcer.class);
+      return MSQTestWorkerContext.this.policyEnforcer();
     }
 
     @Override
diff --git a/processing/src/main/java/org/apache/druid/segment/Segment.java b/processing/src/main/java/org/apache/druid/segment/Segment.java
index 57870db50259..1da4b47f89cd 100644
--- a/processing/src/main/java/org/apache/druid/segment/Segment.java
+++ b/processing/src/main/java/org/apache/druid/segment/Segment.java
@@ -22,7 +22,6 @@
 import org.apache.druid.error.DruidException;
 import org.apache.druid.guice.annotations.PublicApi;
 import org.apache.druid.query.datasourcemetadata.DataSourceMetadataResultValue;
-import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.join.table.IndexedTable;
 import org.apache.druid.timeline.SegmentId;
 import org.joda.time.Interval;
@@ -98,16 +97,6 @@ default <T> T as(@Nonnull Class<T> clazz)
     return null;
   }
 
-  /**
-   * Returns true if the segment complies with the policy restrictions on tables.
-   * <p>
-   * This should be called right before the segment is about to be processed by the query stack.
-   */
-  default boolean validate(PolicyEnforcer policyEnforcer)
-  {
-    return policyEnforcer.validate(this, null);
-  }
-
   default boolean isTombstone()
   {
     return false;
diff --git a/processing/src/main/java/org/apache/druid/segment/SegmentReference.java b/processing/src/main/java/org/apache/druid/segment/SegmentReference.java
index fae2a7b36f65..0ece5c0ef4d3 100644
--- a/processing/src/main/java/org/apache/druid/segment/SegmentReference.java
+++ b/processing/src/main/java/org/apache/druid/segment/SegmentReference.java
@@ -19,6 +19,8 @@
 
 package org.apache.druid.segment;
 
+import org.apache.druid.query.policy.PolicyEnforcer;
+
 /**
  * A {@link Segment} with a associated references, such as {@link ReferenceCountingSegment} where the reference is
  * the segment itself, and {@link org.apache.druid.segment.join.HashJoinSegment} which wraps a
@@ -27,4 +29,15 @@
  */
 public interface SegmentReference extends Segment, ReferenceCountedObject
 {
+
+  /**
+   * Returns true if the segment complies with the policy restrictions on tables.
+   * <p>
+   * This should be called right before the segment is about to be processed by the query stack.
+   */
+  default boolean validate(PolicyEnforcer policyEnforcer)
+  {
+    return policyEnforcer.validate(this, null);
+  }
+
 }
diff --git a/server/src/main/java/org/apache/druid/segment/InlineSegmentWrangler.java b/server/src/main/java/org/apache/druid/segment/InlineSegmentWrangler.java
index 6128dcf49f26..c1a3a5e425b9 100644
--- a/server/src/main/java/org/apache/druid/segment/InlineSegmentWrangler.java
+++ b/server/src/main/java/org/apache/druid/segment/InlineSegmentWrangler.java
@@ -35,7 +35,7 @@
  */
 public class InlineSegmentWrangler implements SegmentWrangler
 {
-  private static final String SEGMENT_ID = "inline";
+  public static final String SEGMENT_ID = "inline";
 
   @Override
   @SuppressWarnings("unchecked")
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/BaseCalciteQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/BaseCalciteQueryTest.java
index aa8542d92bef..53f292d80fc9 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/BaseCalciteQueryTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/BaseCalciteQueryTest.java
@@ -1052,7 +1052,7 @@ public void assertResultsValid(final ResultMatchMode matchMode, final List<Objec
     }
   }
 
-  public void assertResultsEquals(String sql, List<Object[]> expectedResults, List<Object[]> results)
+  public static void assertResultsEquals(String sql, List<Object[]> expectedResults, List<Object[]> results)
   {
     int minSize = Math.min(results.size(), expectedResults.size());
     for (int i = 0; i < minSize; i++) {

From 6415264821c2714275d233c90092e732aa3211e9 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Mon, 7 Apr 2025 09:09:42 -0700
Subject: [PATCH 82/99] another test for unnest in msq

---
 .../druid/msq/sql/MSQTaskQueryMakerTest.java  | 62 ++++++++++++++++++-
 .../query/policy/NoopPolicyEnforcer.java      |  4 +-
 .../druid/query/policy/PolicyEnforcer.java    | 23 +++----
 .../RestrictAllTablesPolicyEnforcer.java      |  4 +-
 .../query/policy/NoopPolicyEnforcerTest.java  |  1 -
 .../RestrictAllTablesPolicyEnforcerTest.java  |  2 -
 6 files changed, 77 insertions(+), 19 deletions(-)

diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
index 2c85067582c2..f01e88880056 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
@@ -23,6 +23,7 @@
 import com.google.common.collect.ImmutableList;
 import com.google.inject.Guice;
 import com.google.inject.Injector;
+import com.google.inject.Key;
 import com.google.inject.Module;
 import com.google.inject.testing.fieldbinder.Bind;
 import com.google.inject.testing.fieldbinder.BoundFieldModule;
@@ -31,8 +32,11 @@
 import org.apache.druid.guice.ConfigModule;
 import org.apache.druid.guice.DruidGuiceExtensions;
 import org.apache.druid.guice.DruidSecondaryModule;
+import org.apache.druid.guice.ExpressionModule;
 import org.apache.druid.guice.LifecycleModule;
 import org.apache.druid.guice.SegmentWranglerModule;
+import org.apache.druid.guice.annotations.Json;
+import org.apache.druid.jackson.DefaultObjectMapper;
 import org.apache.druid.java.util.common.FileUtils;
 import org.apache.druid.java.util.common.concurrent.Execs;
 import org.apache.druid.java.util.common.io.Closer;
@@ -57,6 +61,7 @@
 import org.apache.druid.query.QueryProcessingPool;
 import org.apache.druid.query.RestrictedDataSource;
 import org.apache.druid.query.TableDataSource;
+import org.apache.druid.query.UnnestDataSource;
 import org.apache.druid.query.filter.EqualityFilter;
 import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.policy.PolicyEnforcer;
@@ -88,6 +93,7 @@
 import java.util.function.Supplier;
 
 import static org.apache.druid.sql.calcite.BaseCalciteQueryTest.assertResultsEquals;
+import static org.apache.druid.sql.calcite.BaseCalciteQueryTest.expressionVirtualColumn;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyBoolean;
 import static org.mockito.Mockito.when;
@@ -114,7 +120,7 @@ public class MSQTaskQueryMakerTest
   @Nullable
   private DataServerQueryHandlerFactory dataServerQueryHandlerFactory;
   @Bind(lazy = true)
-  private PolicyEnforcer policyEnforcer;
+  private PolicyEnforcer policyEnforcer; // lazy so we can set it in the test
 
   private MSQTestOverlordServiceClient overlordClient;
 
@@ -139,6 +145,8 @@ public void setUp() throws Exception
     queryProcessingPool = new ForwardingQueryProcessingPool(Execs.singleThreaded("Test-runner-processing-pool"));
     policyEnforcer = NoopPolicyEnforcer.instance();
     Module defaultModule = Modules.combine(
+        binder -> binder.bind(Key.get(ObjectMapper.class, Json.class)).toInstance(new DefaultObjectMapper()),
+        new ExpressionModule(),
         new DruidGuiceExtensions(),
         new LifecycleModule(),
         new ConfigModule(),
@@ -288,6 +296,58 @@ public void testScanQueryPassedPolicyValidation() throws Exception
     );
   }
 
+  @Test
+  public void testUnnestOnRestrictedPassedPolicyValidation() throws Exception
+  {
+    // Arrange
+    policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    UnnestDataSource unnestDataSource = UnnestDataSource.create(
+        RestrictedDataSource.create(
+            TableDataSource.create(CalciteTests.DATASOURCE1),
+            RowFilterPolicy.from(new EqualityFilter(
+                "dim1",
+                ColumnType.STRING,
+                "10.1",
+                null
+            ))
+        ),
+        expressionVirtualColumn("j0.unnest", "\"dim3\"", ColumnType.STRING),
+        null
+    );
+    ScanQuery query = Druids.newScanQueryBuilder()
+                            .resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
+                            .dataSource(unnestDataSource)
+                            .eternityInterval()
+                            .columns("dim1", "j0.unnest")
+                            .columnTypes(ColumnType.STRING, ColumnType.STRING)
+                            .build();
+    RowSignature resultSignature = RowSignature.builder()
+                                               .add("dim1", ColumnType.STRING)
+                                               .add("j0.unnest", ColumnType.STRING)
+                                               .build();
+
+    String controllerTaskId = "scan_query";
+    MSQControllerTask controllerTask = buildMSQControllerTask(
+        controllerTaskId,
+        query,
+        resultSignature,
+        "SELECT dim1 FROM foo, UNNEST(MV_TO_ARRAY(dim3)) as unnested (d3)"
+    );
+    // Act
+    overlordClient.runTask(controllerTaskId, controllerTask).get();
+    MSQTaskReportPayload payload = (MSQTaskReportPayload) overlordClient.getReportForTask(controllerTaskId)
+                                                                        .get(MSQTaskReport.REPORT_KEY)
+                                                                        .getPayload();
+    // Assert
+    Assert.assertTrue(payload.getStatus().getStatus().isSuccess());
+    ImmutableList<Object[]> expectedResults = ImmutableList.of(new Object[]{"10.1", "b"}, new Object[]{"10.1", "c"});
+    assertResultsEquals(
+        "SELECT dim1 FROM foo, UNNEST(MV_TO_ARRAY(dim3)) as unnested (d3) (with restriction)",
+        expectedResults,
+        payload.getResults().getResults()
+    );
+  }
+
   @Test
   public void testInlineDataSourcePassedPolicyValidation() throws Exception
   {
diff --git a/processing/src/main/java/org/apache/druid/query/policy/NoopPolicyEnforcer.java b/processing/src/main/java/org/apache/druid/query/policy/NoopPolicyEnforcer.java
index 38d87fec4440..578dbcc1ac2d 100644
--- a/processing/src/main/java/org/apache/druid/query/policy/NoopPolicyEnforcer.java
+++ b/processing/src/main/java/org/apache/druid/query/policy/NoopPolicyEnforcer.java
@@ -21,7 +21,7 @@
 
 import com.fasterxml.jackson.annotation.JsonCreator;
 import org.apache.druid.query.DataSource;
-import org.apache.druid.segment.Segment;
+import org.apache.druid.segment.SegmentReference;
 
 /**
  * Allows all data sources (no restrictions).
@@ -39,7 +39,7 @@ public boolean validate(DataSource unused, Policy unused2)
   }
 
   @Override
-  public boolean validate(Segment unused, Policy unused2)
+  public boolean validate(SegmentReference unused, Policy unused2)
   {
     return true;
   }
diff --git a/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java b/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
index 3212082bcb40..66627972b07b 100644
--- a/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
+++ b/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
@@ -23,7 +23,7 @@
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import org.apache.druid.guice.annotations.UnstableApi;
 import org.apache.druid.query.DataSource;
-import org.apache.druid.segment.Segment;
+import org.apache.druid.segment.SegmentReference;
 
 /**
  * Interface for enforcing policies on data sources and segments in Druid queries.
@@ -43,27 +43,28 @@ public interface PolicyEnforcer
 {
 
   /**
-   * Validates a {@link DataSource} against the policy enforcer. This method is invoked during query planning
-   * via {@link DataSource#validate(PolicyEnforcer)}.
+   * Validates a {@link DataSource} against the policy enforcer. This method is invoked before query execution
+   * via {@link DataSource#validate(PolicyEnforcer)}. The callsite must ensure that the data source is not a composite
+   * tree, and it must be a druid table. Specifically, it must be one of TableDataSource and RestrictedTableDataSource.
    * <p>
    * Direct invocation of this method is discouraged; use {@link DataSource#validate(PolicyEnforcer)} instead.
    *
-   * @param ds the data source to validate
-   * @param policy the policy on the data source, e.x. {@link RestrictedDataSource#policy} or null for {@link TableDataSource}
+   * @param ds     the data source to validate
+   * @param policy the policy on the data source, e.x. {@link org.apache.druid.query.RestrictedDataSource#policy} or null for {@link org.apache.druid.query.TableDataSource}
    * @return {@code true} if the data source complies with the policy, {@code false} otherwise
    */
   boolean validate(DataSource ds, Policy policy);
 
   /**
-   * Validates a {@link Segment} against the policy enforcer. This method is invoked during query planning
-   * via {@link Segment#validate(PolicyEnforcer)}.
+   * Validates a {@link SegmentReference} against the policy enforcer. This method is invoked before query execution
+   * via {@link SegmentReference#validate(PolicyEnforcer)}. The callsite must ensure that the segment reference is not a
+   * deeply linked segment reference, and it must be referenced to a druid table.
    * <p>
-   * Direct invocation of this method is discouraged; use {@link Segment#validate(PolicyEnforcer)} instead.
-
+   * Direct invocation of this method is discouraged; use {@link SegmentReference#validate(PolicyEnforcer)} instead.
    *
    * @param segment the segment to validate
-   * @param policy the policy on the segment, {@link RestrictedSegment#policy}
+   * @param policy  the policy on the segment, {@link org.apache.druid.segment.RestrictedSegment#policy} or null for other
    * @return {@code true} if the segment complies with the policy, {@code false} otherwise
    */
-  boolean validate(Segment segment, Policy policy);
+  boolean validate(SegmentReference segment, Policy policy);
 }
diff --git a/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java b/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java
index 522dd1227428..eeeff5ad7107 100644
--- a/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java
+++ b/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java
@@ -26,7 +26,7 @@
 import org.apache.druid.query.DataSource;
 import org.apache.druid.query.RestrictedDataSource;
 import org.apache.druid.segment.RestrictedSegment;
-import org.apache.druid.segment.Segment;
+import org.apache.druid.segment.SegmentReference;
 import org.reflections.Reflections;
 
 import javax.annotation.Nullable;
@@ -76,7 +76,7 @@ public boolean validate(DataSource ds, Policy policy)
   }
 
   @Override
-  public boolean validate(Segment segment, Policy policy)
+  public boolean validate(SegmentReference segment, Policy policy)
   {
     if (segment instanceof RestrictedSegment) {
       return allowedPolicies.isEmpty() || allowedPolicies.contains(policy.getClass().getSimpleName());
diff --git a/processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java b/processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java
index 7c2166f81637..78bcced80488 100644
--- a/processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java
@@ -71,7 +71,6 @@ public void test_validate() throws Exception
     Segment baseSegment = new TestSegmentUtils.SegmentForTesting("table", Intervals.ETERNITY, "1");
     SegmentReference segment = ReferenceCountingSegment.wrapRootGenerationSegment(baseSegment);
     RestrictedSegment restrictedSegment = new RestrictedSegment(segment, policy);
-    Assert.assertTrue(policyEnforcer.validate(baseSegment, null));
     Assert.assertTrue(policyEnforcer.validate(segment, null));
     Assert.assertTrue(policyEnforcer.validate(restrictedSegment, policy));
   }
diff --git a/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java b/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
index de85470cf430..9d156b63a830 100644
--- a/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
@@ -72,7 +72,6 @@ public void test_validate() throws Exception
     Segment baseSegment = new SegmentForTesting("table", Intervals.ETERNITY, "1");
     SegmentReference segment = ReferenceCountingSegment.wrapRootGenerationSegment(baseSegment);
     RestrictedSegment restrictedSegment = new RestrictedSegment(segment, policy);
-    Assert.assertFalse(policyEnforcer.validate(baseSegment, null));
     Assert.assertFalse(policyEnforcer.validate(segment, null));
     Assert.assertTrue(policyEnforcer.validate(restrictedSegment, policy));
   }
@@ -92,7 +91,6 @@ public void test_validate_withAllowedPolicies() throws Exception
     Segment baseSegment = new SegmentForTesting("table", Intervals.ETERNITY, "1");
     SegmentReference segment = ReferenceCountingSegment.wrapRootGenerationSegment(baseSegment);
     RestrictedSegment restrictedSegment = new RestrictedSegment(segment, policy);
-    Assert.assertFalse(policyEnforcer.validate(baseSegment, null));
     Assert.assertFalse(policyEnforcer.validate(segment, null));
     Assert.assertFalse(policyEnforcer.validate(restrictedSegment, policy));
   }

From 4756687b7c5f2227084975a9b6047490dd3ea4d0 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Mon, 7 Apr 2025 10:21:37 -0700
Subject: [PATCH 83/99] add support for policy from extension

---
 .../RestrictAllTablesPolicyEnforcer.java      | 29 ++++++++++++++-----
 .../RestrictAllTablesPolicyEnforcerTest.java  | 14 +++++++++
 2 files changed, 35 insertions(+), 8 deletions(-)

diff --git a/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java b/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java
index eeeff5ad7107..3763c3b84f6e 100644
--- a/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java
+++ b/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java
@@ -36,7 +36,7 @@
 import java.util.stream.Collectors;
 
 /**
- * All tables must be restricted by a policy. 
+ * All tables must be restricted by a policy.
  */
 public class RestrictAllTablesPolicyEnforcer implements PolicyEnforcer
 {
@@ -50,17 +50,30 @@ public RestrictAllTablesPolicyEnforcer(
     if (allowedPolicies == null) {
       this.allowedPolicies = ImmutableList.of();
     } else {
-      Set<String> policyClazz = new Reflections("org.apache.druid.query.policy").getSubTypesOf(
-          Policy.class).stream().map(Class::getSimpleName).collect(Collectors.toSet());
-
+      Set<String> policyClazz = new Reflections("org.apache.druid.query.policy").getSubTypesOf(Policy.class)
+                                                                                .stream()
+                                                                                .map(Class::getSimpleName)
+                                                                                .collect(Collectors.toSet());
+      ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
       List<String> unrecognizedClazz = allowedPolicies.stream()
-                                                      .filter(p -> !policyClazz.contains(p))
+                                                      .filter(p -> {
+                                                        if (policyClazz.contains(p)) {
+                                                          return false;
+                                                        }
+                                                        try {
+                                                          // try load the class from its full path
+                                                          Class<?> clazz = classLoader.loadClass(p);
+                                                          return clazz.isAssignableFrom(Policy.class);
+                                                        }
+                                                        catch (ClassNotFoundException e) {
+                                                          return true;
+                                                        }
+                                                      })
                                                       .collect(Collectors.toList());
       Preconditions.checkArgument(
           unrecognizedClazz.isEmpty(),
-          "Unrecognized policy class[%s], must be one of class[%s]",
-          unrecognizedClazz,
-          policyClazz
+          "Unrecognized class[%s], ensure that the class is loaded and is a subclass of Policy",
+          unrecognizedClazz
       );
       this.allowedPolicies = ImmutableList.copyOf(allowedPolicies);
     }
diff --git a/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java b/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
index 9d156b63a830..c58480a67873 100644
--- a/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
@@ -58,6 +58,20 @@ public void test_serde_roundTrip() throws Exception
     Assert.assertEquals(policyEnforcer, deserialized);
   }
 
+  @Test
+  public void test_unrecognizedClass() throws Exception
+  {
+    Exception e = Assert.assertThrows(
+        Exception.class,
+        () -> new RestrictAllTablesPolicyEnforcer(ImmutableList.of("UnrecognizedClass"))
+    );
+    Assert.assertEquals(
+        "Unrecognized class[[UnrecognizedClass]], ensure that the class is loaded and is a subclass of Policy",
+        e.getMessage()
+    );
+
+  }
+
   @Test
   public void test_validate() throws Exception
   {

From 7104472f743c412e6ff5e297ec9f630760088590 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Mon, 7 Apr 2025 10:39:58 -0700
Subject: [PATCH 84/99] more test

---
 .../policy/RestrictAllTablesPolicyEnforcer.java |  8 ++++++--
 .../org/apache/druid/query/DataSourceTest.java  | 17 +++++++++++++++++
 2 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java b/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java
index 3763c3b84f6e..61b1be12828c 100644
--- a/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java
+++ b/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java
@@ -83,7 +83,9 @@ public RestrictAllTablesPolicyEnforcer(
   public boolean validate(DataSource ds, Policy policy)
   {
     if (ds instanceof RestrictedDataSource) {
-      return allowedPolicies.isEmpty() || allowedPolicies.contains(policy.getClass().getSimpleName());
+      return allowedPolicies.isEmpty()
+             || allowedPolicies.contains(policy.getClass().getSimpleName())
+             || allowedPolicies.contains(policy.getClass().getName());
     }
     return false;
   }
@@ -92,7 +94,9 @@ public boolean validate(DataSource ds, Policy policy)
   public boolean validate(SegmentReference segment, Policy policy)
   {
     if (segment instanceof RestrictedSegment) {
-      return allowedPolicies.isEmpty() || allowedPolicies.contains(policy.getClass().getSimpleName());
+      return allowedPolicies.isEmpty()
+             || allowedPolicies.contains(policy.getClass().getSimpleName())
+             || allowedPolicies.contains(policy.getClass().getName());
     }
     return false;
   }
diff --git a/processing/src/test/java/org/apache/druid/query/DataSourceTest.java b/processing/src/test/java/org/apache/druid/query/DataSourceTest.java
index d5bd2314093d..52e4c142fb80 100644
--- a/processing/src/test/java/org/apache/druid/query/DataSourceTest.java
+++ b/processing/src/test/java/org/apache/druid/query/DataSourceTest.java
@@ -273,5 +273,22 @@ public void testValidate_onUnionDataSource()
     // Fail, only NoRestrictionPolicy is allowed.
     Assert.assertFalse(unionDataSource.validate(new RestrictAllTablesPolicyEnforcer(ImmutableList.of(
         "NoRestrictionPolicy"))));
+
+
+    UnionDataSource unionDataSource2 = new UnionDataSource(Lists.newArrayList(
+        RestrictedDataSource.create(
+            TableDataSource.create("table1"),
+            RowFilterPolicy.from(new NullFilter("random-column", null))
+        ),
+        RestrictedDataSource.create(
+            TableDataSource.create("table2"),
+            RowFilterPolicy.from(new NullFilter("random-column2", null))
+        )
+    ));
+    Assert.assertTrue(unionDataSource2.validate(NoopPolicyEnforcer.instance()));
+    Assert.assertTrue(unionDataSource2.validate(new RestrictAllTablesPolicyEnforcer(null)));
+    // Fail, only NoRestrictionPolicy is allowed.
+    Assert.assertFalse(unionDataSource2.validate(new RestrictAllTablesPolicyEnforcer(ImmutableList.of(
+        "NoRestrictionPolicy"))));
   }
 }

From 61ad96a120208cbf4efa052a6685e29ad7060432 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Mon, 7 Apr 2025 16:55:50 -0700
Subject: [PATCH 85/99] refactor MSQTaskQueryMakerTest to use an instance of
 MSQTaskQueryMaker

---
 .../druid/msq/sql/MSQTaskQueryMaker.java      |  12 +
 .../druid/msq/sql/MSQTaskSqlEngine.java       |   6 +
 .../druid/msq/exec/TestMSQSqlModule.java      |  12 +-
 .../druid/msq/sql/MSQTaskQueryMakerTest.java  | 368 ++++++++++--------
 .../apache/druid/msq/test/MSQTestBase.java    |   1 +
 .../guice/security/PolicyModuleTest.java      |   2 +-
 6 files changed, 239 insertions(+), 162 deletions(-)

diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java
index 0b777dae88ba..5bd49dc42274 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java
@@ -55,6 +55,7 @@
 import org.apache.druid.query.QueryContext;
 import org.apache.druid.query.QueryContexts;
 import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.rpc.indexing.OverlordClient;
 import org.apache.druid.segment.IndexSpec;
 import org.apache.druid.segment.column.ColumnType;
@@ -98,6 +99,7 @@ public class MSQTaskQueryMaker implements QueryMaker
   private final IngestDestination targetDataSource;
   private final OverlordClient overlordClient;
   private final PlannerContext plannerContext;
+  private final PolicyEnforcer policyEnforcer;
   private final ObjectMapper jsonMapper;
   private final List<Entry<Integer, String>> fieldMapping;
   private final MSQTerminalStageSpecFactory terminalStageSpecFactory;
@@ -106,6 +108,7 @@ public class MSQTaskQueryMaker implements QueryMaker
       @Nullable final IngestDestination targetDataSource,
       final OverlordClient overlordClient,
       final PlannerContext plannerContext,
+      final PolicyEnforcer policyEnforcer,
       final ObjectMapper jsonMapper,
       final List<Entry<Integer, String>> fieldMapping,
       final MSQTerminalStageSpecFactory terminalStageSpecFactory
@@ -114,6 +117,7 @@ public class MSQTaskQueryMaker implements QueryMaker
     this.targetDataSource = targetDataSource;
     this.overlordClient = Preconditions.checkNotNull(overlordClient, "indexingServiceClient");
     this.plannerContext = Preconditions.checkNotNull(plannerContext, "plannerContext");
+    this.policyEnforcer = Preconditions.checkNotNull(policyEnforcer, "policyEnforcer");
     this.jsonMapper = Preconditions.checkNotNull(jsonMapper, "jsonMapper");
     this.fieldMapping = Preconditions.checkNotNull(fieldMapping, "fieldMapping");
     this.terminalStageSpecFactory = terminalStageSpecFactory;
@@ -124,6 +128,14 @@ public QueryResponse<Object[]> runQuery(final DruidQuery druidQuery)
   {
     Hook.QUERY_PLAN.run(druidQuery.getQuery());
     plannerContext.dispatchHook(DruidHook.NATIVE_PLAN, druidQuery.getQuery());
+    if (!druidQuery.getQuery().getDataSource().validate(policyEnforcer)) {
+      throw DruidException.forPersona(DruidException.Persona.OPERATOR)
+                          .ofCategory(DruidException.Category.FORBIDDEN)
+                          .build(
+                              "Failed security validation with dataSource [%s]",
+                              druidQuery.getQuery().getDataSource()
+                          );
+    }
 
     String taskId = MSQTasks.controllerTaskId(plannerContext.getSqlQueryId());
 
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskSqlEngine.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskSqlEngine.java
index 31a2f5e5e643..fa2ca9869793 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskSqlEngine.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskSqlEngine.java
@@ -49,6 +49,7 @@
 import org.apache.druid.msq.util.DimensionSchemaUtils;
 import org.apache.druid.msq.util.MultiStageQueryContext;
 import org.apache.druid.query.QueryContext;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.rpc.indexing.OverlordClient;
 import org.apache.druid.segment.column.ColumnHolder;
 import org.apache.druid.segment.column.ColumnType;
@@ -89,17 +90,20 @@ public class MSQTaskSqlEngine implements SqlEngine
   private static final String NAME = "msq-task";
 
   private final OverlordClient overlordClient;
+  private final PolicyEnforcer policyEnforcer;
   private final ObjectMapper jsonMapper;
   private final MSQTerminalStageSpecFactory terminalStageSpecFactory;
 
   @Inject
   public MSQTaskSqlEngine(
       final OverlordClient overlordClient,
+      final PolicyEnforcer policyEnforcer,
       final ObjectMapper jsonMapper,
       final MSQTerminalStageSpecFactory terminalStageSpecFactory
   )
   {
     this.overlordClient = overlordClient;
+    this.policyEnforcer = policyEnforcer;
     this.jsonMapper = jsonMapper;
     this.terminalStageSpecFactory = terminalStageSpecFactory;
   }
@@ -177,6 +181,7 @@ public QueryMaker buildQueryMakerForSelect(
         null,
         overlordClient,
         plannerContext,
+        policyEnforcer,
         jsonMapper,
         relRoot.fields,
         terminalStageSpecFactory
@@ -211,6 +216,7 @@ public QueryMaker buildQueryMakerForInsert(
         destination,
         overlordClient,
         plannerContext,
+        policyEnforcer,
         jsonMapper,
         relRoot.fields,
         terminalStageSpecFactory
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/TestMSQSqlModule.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/TestMSQSqlModule.java
index 0b48d2904dd3..b4c9e0e152c3 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/TestMSQSqlModule.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/TestMSQSqlModule.java
@@ -31,6 +31,7 @@
 import org.apache.druid.msq.test.MSQTestBase;
 import org.apache.druid.msq.test.MSQTestOverlordServiceClient;
 import org.apache.druid.msq.test.MSQTestTaskActionClient;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.sql.SqlStatementFactory;
 import org.apache.druid.sql.SqlToolbox;
 import org.apache.druid.sql.avatica.DruidMeta;
@@ -50,11 +51,14 @@ public SqlStatementFactory makeMSQSqlStatementFactory(
 
   @Provides
   @LazySingleton
-  public MSQTaskSqlEngine createEngine(
-      ObjectMapper queryJsonMapper,
-      MSQTestOverlordServiceClient indexingServiceClient)
+  public MSQTaskSqlEngine createEngine(ObjectMapper queryJsonMapper, MSQTestOverlordServiceClient indexingServiceClient)
   {
-    return new MSQTaskSqlEngine(indexingServiceClient, queryJsonMapper, new SegmentGenerationTerminalStageSpecFactory());
+    return new MSQTaskSqlEngine(
+        indexingServiceClient,
+        NoopPolicyEnforcer.instance(),
+        queryJsonMapper,
+        new SegmentGenerationTerminalStageSpecFactory()
+    );
   }
 
   @Provides
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
index f01e88880056..50dfef8c9d5c 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
@@ -21,14 +21,17 @@
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
 import com.google.inject.Guice;
 import com.google.inject.Injector;
-import com.google.inject.Key;
 import com.google.inject.Module;
 import com.google.inject.testing.fieldbinder.Bind;
 import com.google.inject.testing.fieldbinder.BoundFieldModule;
 import com.google.inject.util.Modules;
+import org.apache.calcite.jdbc.JavaTypeFactoryImpl;
 import org.apache.druid.collections.ReferenceCountingResourceHolder;
+import org.apache.druid.error.DruidException;
 import org.apache.druid.guice.ConfigModule;
 import org.apache.druid.guice.DruidGuiceExtensions;
 import org.apache.druid.guice.DruidSecondaryModule;
@@ -41,11 +44,8 @@
 import org.apache.druid.java.util.common.concurrent.Execs;
 import org.apache.druid.java.util.common.io.Closer;
 import org.apache.druid.msq.exec.DataServerQueryHandlerFactory;
-import org.apache.druid.msq.indexing.MSQControllerTask;
-import org.apache.druid.msq.indexing.MSQSpec;
-import org.apache.druid.msq.indexing.MSQTuningConfig;
-import org.apache.druid.msq.indexing.destination.TaskReportMSQDestination;
-import org.apache.druid.msq.indexing.error.MSQErrorReport;
+import org.apache.druid.msq.indexing.destination.MSQTerminalStageSpecFactory;
+import org.apache.druid.msq.indexing.destination.SegmentGenerationTerminalStageSpecFactory;
 import org.apache.druid.msq.indexing.report.MSQTaskReport;
 import org.apache.druid.msq.indexing.report.MSQTaskReportPayload;
 import org.apache.druid.msq.querykit.DataSegmentProvider;
@@ -58,6 +58,7 @@
 import org.apache.druid.query.LookupDataSource;
 import org.apache.druid.query.OrderBy;
 import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryContext;
 import org.apache.druid.query.QueryProcessingPool;
 import org.apache.druid.query.RestrictedDataSource;
 import org.apache.druid.query.TableDataSource;
@@ -68,32 +69,45 @@
 import org.apache.druid.query.policy.RestrictAllTablesPolicyEnforcer;
 import org.apache.druid.query.policy.RowFilterPolicy;
 import org.apache.druid.query.scan.ScanQuery;
+import org.apache.druid.rpc.indexing.OverlordClient;
 import org.apache.druid.segment.IndexIO;
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.segment.column.ColumnConfig;
 import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.column.RowSignature;
+import org.apache.druid.server.QueryResponse;
 import org.apache.druid.server.QueryStackTests;
 import org.apache.druid.server.SpecificSegmentsQuerySegmentWalker;
-import org.apache.druid.sql.calcite.planner.ColumnMappings;
+import org.apache.druid.server.lookup.cache.LookupLoadingSpec;
+import org.apache.druid.server.security.AuthenticationResult;
+import org.apache.druid.sql.calcite.planner.PlannerContext;
+import org.apache.druid.sql.calcite.rel.DruidQuery;
 import org.apache.druid.sql.calcite.util.CalciteTests;
 import org.apache.druid.sql.calcite.util.LookylooModule;
 import org.apache.druid.sql.calcite.util.TestDataBuilder;
+import org.apache.druid.sql.destination.IngestDestination;
 import org.apache.druid.timeline.SegmentId;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.mockito.Mock;
+import org.mockito.Mockito;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoRule;
 
 import javax.annotation.Nullable;
 import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
 import java.util.function.Supplier;
+import java.util.stream.IntStream;
 
+import static java.util.stream.Collectors.toMap;
 import static org.apache.druid.sql.calcite.BaseCalciteQueryTest.assertResultsEquals;
 import static org.apache.druid.sql.calcite.BaseCalciteQueryTest.expressionVirtualColumn;
+import static org.apache.druid.sql.calcite.table.RowSignatures.toRelDataType;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyBoolean;
 import static org.mockito.Mockito.when;
@@ -101,6 +115,7 @@
 public class MSQTaskQueryMakerTest
 {
   private static final Closer CLOSER = Closer.create();
+  private static final JavaTypeFactoryImpl JAVA_TYPE_FACTORY = new JavaTypeFactoryImpl();
 
   @Rule
   public MockitoRule mockitoRule = MockitoJUnit.rule();
@@ -113,16 +128,31 @@ public class MSQTaskQueryMakerTest
   @Bind
   private ObjectMapper objectMapper;
   @Bind
+  @Json
+  private ObjectMapper jsonMapper;
+  @Bind
   private IndexIO indexIO;
   @Bind
+  @Nullable
+  private IngestDestination ingestDestination;
+  @Bind
   private QueryProcessingPool queryProcessingPool;
   @Bind
   @Nullable
   private DataServerQueryHandlerFactory dataServerQueryHandlerFactory;
   @Bind(lazy = true)
   private PolicyEnforcer policyEnforcer; // lazy so we can set it in the test
+  @Bind
+  private MSQTerminalStageSpecFactory terminalStageSpecFactory;
+  @Bind
+  @Mock
+  private PlannerContext plannerContextMock;
+  @Bind(lazy = true)
+  private List<Map.Entry<Integer, String>> fieldMapping; // lazy so we can set it in the test
+  @Bind(lazy = true)
+  private OverlordClient fakeOverlordClient; // lazy since we need to use the injector to create it
 
-  private MSQTestOverlordServiceClient overlordClient;
+  private MSQTaskQueryMaker msqTaskQueryMaker;
 
   @Before
   public void setUp() throws Exception
@@ -141,11 +171,23 @@ public void setUp() throws Exception
     });
 
     objectMapper = TestHelper.makeJsonMapper();
+    jsonMapper = new DefaultObjectMapper();
     indexIO = new IndexIO(objectMapper, ColumnConfig.DEFAULT);
     queryProcessingPool = new ForwardingQueryProcessingPool(Execs.singleThreaded("Test-runner-processing-pool"));
     policyEnforcer = NoopPolicyEnforcer.instance();
+    terminalStageSpecFactory = new SegmentGenerationTerminalStageSpecFactory();
+    when(plannerContextMock.getLookupLoadingSpec()).thenReturn(LookupLoadingSpec.NONE);
+    when(plannerContextMock.queryContext()).thenReturn(new QueryContext(ImmutableMap.of()));
+    when(plannerContextMock.getSql()).thenReturn("stub a sql statement, ignore this value");
+    when(plannerContextMock.getJsonMapper()).thenReturn(jsonMapper);
+    when(plannerContextMock.getAuthenticationResult()).thenReturn(new AuthenticationResult(
+        "someone",
+        "ignore",
+        "ignore",
+        ImmutableMap.of()
+    ));
+
     Module defaultModule = Modules.combine(
-        binder -> binder.bind(Key.get(ObjectMapper.class, Json.class)).toInstance(new DefaultObjectMapper()),
         new ExpressionModule(),
         new DruidGuiceExtensions(),
         new LifecycleModule(),
@@ -155,8 +197,7 @@ public void setUp() throws Exception
     );
     Injector injector = Guice.createInjector(defaultModule, BoundFieldModule.of(this));
     DruidSecondaryModule.setupJackson(injector, objectMapper);
-
-    overlordClient = new MSQTestOverlordServiceClient(
+    fakeOverlordClient = new MSQTestOverlordServiceClient(
         objectMapper,
         injector,
         new MSQTestTaskActionClient(objectMapper, injector),
@@ -169,40 +210,35 @@ public void setUp() throws Exception
   public void testSimpleScanQuery() throws Exception
   {
     // Arrange
-    ScanQuery query = new Druids.ScanQueryBuilder()
-        .resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
-        .eternityInterval()
-        .dataSource(CalciteTests.DATASOURCE1)
-        .columns(ImmutableList.of("cnt", "dim1"))
-        .columnTypes(ColumnType.LONG, ColumnType.STRING)
-        .build();
     RowSignature resultSignature = RowSignature.builder()
                                                .add("cnt", ColumnType.LONG)
                                                .add("dim1", ColumnType.STRING)
                                                .build();
-    String controllerTaskId = "scan_query";
-    MSQControllerTask controllerTask = new MSQControllerTask(
-        controllerTaskId,
-        MSQSpec.builder()
-               .query(query)
-               .columnMappings(ColumnMappings.identity(resultSignature))
-               .tuningConfig(MSQTuningConfig.defaultConfig())
-               .destination(TaskReportMSQDestination.INSTANCE)
-               .build(),
-        "select cnt, dim1 from foo",
-        null,
-        null,
-        null,
-        null,
-        null,
-        null
-    );
+    fieldMapping = buildFieldMapping(resultSignature);
+    Query query = new Druids.ScanQueryBuilder().resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
+                                               .eternityInterval()
+                                               .dataSource(CalciteTests.DATASOURCE1)
+                                               .columns(resultSignature.getColumnNames())
+                                               .columnTypes(resultSignature.getColumnTypes())
+                                               .build();
+    DruidQuery druidQueryMock = buildDruidQueryMock(query, resultSignature);
     // Act
-    overlordClient.runTask(controllerTaskId, controllerTask).get();
-    MSQTaskReportPayload payload = (MSQTaskReportPayload) overlordClient.getReportForTask(controllerTaskId)
-                                                                        .get(MSQTaskReport.REPORT_KEY)
-                                                                        .getPayload();
+    msqTaskQueryMaker = new MSQTaskQueryMaker(
+        ingestDestination,
+        fakeOverlordClient,
+        plannerContextMock,
+        policyEnforcer,
+        objectMapper,
+        fieldMapping,
+        terminalStageSpecFactory
+    );
+    QueryResponse<Object[]> response = msqTaskQueryMaker.runQuery(druidQueryMock);
     // Assert
+    String taskId = (String) Iterables.getOnlyElement(response.getResults().toList())[0];
+    MSQTaskReportPayload payload = (MSQTaskReportPayload) fakeOverlordClient.taskReportAsMap(taskId)
+                                                                            .get()
+                                                                            .get(MSQTaskReport.REPORT_KEY)
+                                                                            .getPayload();
     Assert.assertTrue(payload.getStatus().getStatus().isSuccess());
     ImmutableList<Object[]> expectedResults = ImmutableList.of(
         new Object[]{1L, ""},
@@ -220,33 +256,31 @@ public void testScanQueryFailWithPolicyValidation() throws Exception
   {
     // Arrange
     policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
-    ScanQuery query = new Druids.ScanQueryBuilder()
-        .resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
-        .eternityInterval()
-        .dataSource(CalciteTests.DATASOURCE1)
-        .columns(ImmutableList.of("cnt", "dim1"))
-        .columnTypes(ColumnType.LONG, ColumnType.STRING)
-        .build();
     RowSignature resultSignature = RowSignature.builder()
                                                .add("cnt", ColumnType.LONG)
                                                .add("dim1", ColumnType.STRING)
                                                .build();
-    String controllerTaskId = "scan_query";
-    MSQControllerTask controllerTask = buildMSQControllerTask(
-        controllerTaskId,
-        query,
-        resultSignature,
-        "select cnt, dim1 from foo"
-    );
+    fieldMapping = buildFieldMapping(resultSignature);
+    Query query = new Druids.ScanQueryBuilder().resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
+                                               .eternityInterval()
+                                               .dataSource(CalciteTests.DATASOURCE1)
+                                               .columns(resultSignature.getColumnNames())
+                                               .columnTypes(resultSignature.getColumnTypes())
+                                               .build();
+    DruidQuery druidQueryMock = buildDruidQueryMock(query, resultSignature);
     // Act
-    overlordClient.runTask(controllerTaskId, controllerTask).get();
-    MSQTaskReportPayload payload = (MSQTaskReportPayload) overlordClient.getReportForTask(controllerTaskId)
-                                                                        .get(MSQTaskReport.REPORT_KEY)
-                                                                        .getPayload();
+    msqTaskQueryMaker = new MSQTaskQueryMaker(
+        ingestDestination,
+        fakeOverlordClient,
+        plannerContextMock,
+        policyEnforcer,
+        objectMapper,
+        fieldMapping,
+        terminalStageSpecFactory
+    );
     // Assert
-    Assert.assertTrue(payload.getStatus().getStatus().isFailure());
-    MSQErrorReport errorReport = payload.getStatus().getErrorReport();
-    Assert.assertTrue(errorReport.getFault().getErrorMessage().contains("Failed security validation"));
+    DruidException e = Assert.assertThrows(DruidException.class, () -> msqTaskQueryMaker.runQuery(druidQueryMock));
+    Assert.assertTrue(e.getMessage().contains("Failed security validation with dataSource [foo]"));
   }
 
   @Test
@@ -254,6 +288,11 @@ public void testScanQueryPassedPolicyValidation() throws Exception
   {
     // Arrange
     policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    RowSignature resultSignature = RowSignature.builder()
+                                               .add("cnt", ColumnType.LONG)
+                                               .add("dim1", ColumnType.STRING)
+                                               .build();
+    fieldMapping = buildFieldMapping(resultSignature);
     RestrictedDataSource restrictedDataSource = RestrictedDataSource.create(
         TableDataSource.create(CalciteTests.DATASOURCE1),
         RowFilterPolicy.from(new EqualityFilter(
@@ -263,30 +302,30 @@ public void testScanQueryPassedPolicyValidation() throws Exception
             null
         ))
     );
-    ScanQuery query = new Druids.ScanQueryBuilder()
-        .resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
-        .eternityInterval()
-        .dataSource(restrictedDataSource)
-        .columns(ImmutableList.of("cnt", "dim1"))
-        .columnTypes(ColumnType.LONG, ColumnType.STRING)
-        .build();
-    RowSignature resultSignature = RowSignature.builder()
-                                               .add("cnt", ColumnType.LONG)
-                                               .add("dim1", ColumnType.STRING)
+    Query query = new Druids.ScanQueryBuilder().resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
+                                               .eternityInterval()
+                                               .dataSource(restrictedDataSource)
+                                               .columns(resultSignature.getColumnNames())
+                                               .columnTypes(resultSignature.getColumnTypes())
                                                .build();
-    String controllerTaskId = "scan_query";
-    MSQControllerTask controllerTask = buildMSQControllerTask(
-        controllerTaskId,
-        query,
-        resultSignature,
-        "select cnt, dim1 from foo (with restriction)"
-    );
+    DruidQuery druidQueryMock = buildDruidQueryMock(query, resultSignature);
     // Act
-    overlordClient.runTask(controllerTaskId, controllerTask).get();
-    MSQTaskReportPayload payload = (MSQTaskReportPayload) overlordClient.getReportForTask(controllerTaskId)
-                                                                        .get(MSQTaskReport.REPORT_KEY)
-                                                                        .getPayload();
+    msqTaskQueryMaker = new MSQTaskQueryMaker(
+        ingestDestination,
+        fakeOverlordClient,
+        plannerContextMock,
+        policyEnforcer,
+        objectMapper,
+        fieldMapping,
+        terminalStageSpecFactory
+    );
+    QueryResponse<Object[]> response = msqTaskQueryMaker.runQuery(druidQueryMock);
     // Assert
+    String taskId = (String) Iterables.getOnlyElement(response.getResults().toList())[0];
+    MSQTaskReportPayload payload = (MSQTaskReportPayload) fakeOverlordClient.taskReportAsMap(taskId)
+                                                                            .get()
+                                                                            .get(MSQTaskReport.REPORT_KEY)
+                                                                            .getPayload();
     Assert.assertTrue(payload.getStatus().getStatus().isSuccess());
     ImmutableList<Object[]> expectedResults = ImmutableList.of(new Object[]{1L, "abc"});
     assertResultsEquals(
@@ -301,6 +340,11 @@ public void testUnnestOnRestrictedPassedPolicyValidation() throws Exception
   {
     // Arrange
     policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    RowSignature resultSignature = RowSignature.builder()
+                                               .add("dim1", ColumnType.STRING)
+                                               .add("j0.unnest", ColumnType.STRING)
+                                               .build();
+    fieldMapping = buildFieldMapping(resultSignature);
     UnnestDataSource unnestDataSource = UnnestDataSource.create(
         RestrictedDataSource.create(
             TableDataSource.create(CalciteTests.DATASOURCE1),
@@ -314,31 +358,30 @@ public void testUnnestOnRestrictedPassedPolicyValidation() throws Exception
         expressionVirtualColumn("j0.unnest", "\"dim3\"", ColumnType.STRING),
         null
     );
-    ScanQuery query = Druids.newScanQueryBuilder()
-                            .resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
-                            .dataSource(unnestDataSource)
-                            .eternityInterval()
-                            .columns("dim1", "j0.unnest")
-                            .columnTypes(ColumnType.STRING, ColumnType.STRING)
-                            .build();
-    RowSignature resultSignature = RowSignature.builder()
-                                               .add("dim1", ColumnType.STRING)
-                                               .add("j0.unnest", ColumnType.STRING)
+    Query query = new Druids.ScanQueryBuilder().resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
+                                               .dataSource(unnestDataSource)
+                                               .eternityInterval()
+                                               .columns(resultSignature.getColumnNames())
+                                               .columnTypes(resultSignature.getColumnTypes())
                                                .build();
-
-    String controllerTaskId = "scan_query";
-    MSQControllerTask controllerTask = buildMSQControllerTask(
-        controllerTaskId,
-        query,
-        resultSignature,
-        "SELECT dim1 FROM foo, UNNEST(MV_TO_ARRAY(dim3)) as unnested (d3)"
-    );
+    DruidQuery druidQueryMock = buildDruidQueryMock(query, resultSignature);
     // Act
-    overlordClient.runTask(controllerTaskId, controllerTask).get();
-    MSQTaskReportPayload payload = (MSQTaskReportPayload) overlordClient.getReportForTask(controllerTaskId)
-                                                                        .get(MSQTaskReport.REPORT_KEY)
-                                                                        .getPayload();
+    msqTaskQueryMaker = new MSQTaskQueryMaker(
+        ingestDestination,
+        fakeOverlordClient,
+        plannerContextMock,
+        policyEnforcer,
+        objectMapper,
+        fieldMapping,
+        terminalStageSpecFactory
+    );
+    QueryResponse<Object[]> response = msqTaskQueryMaker.runQuery(druidQueryMock);
     // Assert
+    String taskId = (String) Iterables.getOnlyElement(response.getResults().toList())[0];
+    MSQTaskReportPayload payload = (MSQTaskReportPayload) fakeOverlordClient.taskReportAsMap(taskId)
+                                                                            .get()
+                                                                            .get(MSQTaskReport.REPORT_KEY)
+                                                                            .getPayload();
     Assert.assertTrue(payload.getStatus().getStatus().isSuccess());
     ImmutableList<Object[]> expectedResults = ImmutableList.of(new Object[]{"10.1", "b"}, new Object[]{"10.1", "c"});
     assertResultsEquals(
@@ -356,24 +399,35 @@ public void testInlineDataSourcePassedPolicyValidation() throws Exception
     RowSignature resultSignature = RowSignature.builder()
                                                .add("EXPR$0", ColumnType.LONG)
                                                .build();
+    fieldMapping = buildFieldMapping(resultSignature);
     InlineDataSource inlineDataSource = InlineDataSource.fromIterable(
         ImmutableList.of(new Object[]{2L}),
         resultSignature
     );
-    ScanQuery query = Druids.newScanQueryBuilder()
-                            .dataSource(inlineDataSource)
-                            .eternityInterval()
-                            .columns("EXPR$0")
-                            .columnTypes(ColumnType.LONG)
-                            .build();
-    String controllerTaskId = "scan_query";
-    MSQControllerTask controllerTask = buildMSQControllerTask(controllerTaskId, query, resultSignature, "select 1 + 1");
+    Query query = new Druids.ScanQueryBuilder().resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
+                                               .dataSource(inlineDataSource)
+                                               .eternityInterval()
+                                               .columns(resultSignature.getColumnNames())
+                                               .columnTypes(resultSignature.getColumnTypes())
+                                               .build();
+    DruidQuery druidQueryMock = buildDruidQueryMock(query, resultSignature);
     // Act
-    overlordClient.runTask(controllerTaskId, controllerTask).get();
-    MSQTaskReportPayload payload = (MSQTaskReportPayload) overlordClient.getReportForTask(controllerTaskId)
-                                                                        .get(MSQTaskReport.REPORT_KEY)
-                                                                        .getPayload();
+    msqTaskQueryMaker = new MSQTaskQueryMaker(
+        ingestDestination,
+        fakeOverlordClient,
+        plannerContextMock,
+        policyEnforcer,
+        objectMapper,
+        fieldMapping,
+        terminalStageSpecFactory
+    );
+    QueryResponse<Object[]> response = msqTaskQueryMaker.runQuery(druidQueryMock);
     // Assert
+    String taskId = (String) Iterables.getOnlyElement(response.getResults().toList())[0];
+    MSQTaskReportPayload payload = (MSQTaskReportPayload) fakeOverlordClient.taskReportAsMap(taskId)
+                                                                            .get()
+                                                                            .get(MSQTaskReport.REPORT_KEY)
+                                                                            .getPayload();
     Assert.assertTrue(payload.getStatus().getStatus().isSuccess());
     ImmutableList<Object[]> expectedResults = ImmutableList.of(new Object[]{2L});
     assertResultsEquals("select 1 + 1", expectedResults, payload.getResults().getResults());
@@ -384,27 +438,33 @@ public void testLookupDataSourcePassedPolicyValidation() throws Exception
   {
     // Arrange
     policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
-    final RowSignature rowSignature = RowSignature.builder().add("v", ColumnType.STRING).build();
-    ScanQuery query = Druids.newScanQueryBuilder()
-                            .resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
-                            .eternityInterval()
-                            .dataSource(new LookupDataSource("lookyloo"))
-                            .columns(ImmutableList.of("v"))
-                            .columnTypes(ColumnType.STRING)
-                            .orderBy(ImmutableList.of(OrderBy.ascending("v")))
-                            .build();
-    String controllerTaskId = "scan_query";
-    MSQControllerTask controllerTask = buildMSQControllerTask(
-        controllerTaskId,
-        query,
-        rowSignature,
-        "select v from lookyloo"
-    );
+    final RowSignature resultSignature = RowSignature.builder().add("v", ColumnType.STRING).build();
+    fieldMapping = buildFieldMapping(resultSignature);
+    Query query = new Druids.ScanQueryBuilder().resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
+                                               .eternityInterval()
+                                               .dataSource(new LookupDataSource("lookyloo"))
+                                               .columns(resultSignature.getColumnNames())
+                                               .columnTypes(resultSignature.getColumnTypes())
+                                               .orderBy(ImmutableList.of(OrderBy.ascending("v")))
+                                               .build();
+    DruidQuery druidQueryMock = buildDruidQueryMock(query, resultSignature);
     // Act
-    overlordClient.runTask(controllerTaskId, controllerTask).get();
-    MSQTaskReportPayload payload = (MSQTaskReportPayload) overlordClient.getReportForTask(controllerTaskId)
-                                                                        .get(MSQTaskReport.REPORT_KEY)
-                                                                        .getPayload();
+    msqTaskQueryMaker = new MSQTaskQueryMaker(
+        ingestDestination,
+        fakeOverlordClient,
+        plannerContextMock,
+        policyEnforcer,
+        objectMapper,
+        fieldMapping,
+        terminalStageSpecFactory
+    );
+    QueryResponse<Object[]> response = msqTaskQueryMaker.runQuery(druidQueryMock);
+    // Assert
+    String taskId = (String) Iterables.getOnlyElement(response.getResults().toList())[0];
+    MSQTaskReportPayload payload = (MSQTaskReportPayload) fakeOverlordClient.taskReportAsMap(taskId)
+                                                                            .get()
+                                                                            .get(MSQTaskReport.REPORT_KEY)
+                                                                            .getPayload();
     // Assert
     Assert.assertTrue(payload.getStatus().getStatus().isSuccess());
     ImmutableList<Object[]> expectedResults = ImmutableList.of(
@@ -416,28 +476,22 @@ public void testLookupDataSourcePassedPolicyValidation() throws Exception
     assertResultsEquals("select v from lookyloo", expectedResults, payload.getResults().getResults());
   }
 
-  private static MSQControllerTask buildMSQControllerTask(
-      String controllerTaskId,
-      Query<?> query,
-      RowSignature resultSignature,
-      String sql
-  )
+  private static DruidQuery buildDruidQueryMock(Query query, RowSignature resultSignature)
   {
-    return new MSQControllerTask(
-        controllerTaskId,
-        MSQSpec.builder()
-               .query(query)
-               .columnMappings(ColumnMappings.identity(resultSignature))
-               .tuningConfig(MSQTuningConfig.defaultConfig())
-               .destination(TaskReportMSQDestination.INSTANCE)
-               .build(),
-        sql,
-        null,
-        null,
-        null,
-        null,
-        null,
-        null
-    );
+    DruidQuery druidQueryMock = Mockito.mock(DruidQuery.class);
+    when(druidQueryMock.getQuery()).thenReturn(query);
+    when(druidQueryMock.getDataSource()).thenReturn(query.getDataSource());
+    when(druidQueryMock.getOutputRowSignature()).thenReturn(resultSignature);
+    when(druidQueryMock.getOutputRowType()).thenReturn(toRelDataType(resultSignature, JAVA_TYPE_FACTORY, false));
+    return druidQueryMock;
+  }
+
+  private static List<Map.Entry<Integer, String>> buildFieldMapping(RowSignature resultSignature)
+  {
+    List<String> columns = resultSignature.getColumnNames();
+    return ImmutableList.copyOf(IntStream.range(0, columns.size())
+                                         .boxed()
+                                         .collect(toMap(Function.identity(), columns::get))
+                                         .entrySet());
   }
 }
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestBase.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestBase.java
index 9d4900912afc..5db75e7fec66 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestBase.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestBase.java
@@ -574,6 +574,7 @@ public String getFormatString()
 
     final SqlEngine engine = new MSQTaskSqlEngine(
         indexingServiceClient,
+        NoopPolicyEnforcer.instance(),
         qf.queryJsonMapper().copy().registerModules(new MSQSqlModule().getJacksonModules()),
         new SegmentGenerationTerminalStageSpecFactory()
     );
diff --git a/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java b/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
index 4304ef02871c..a8a5d5393a70 100644
--- a/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
+++ b/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
@@ -126,6 +126,6 @@ public void testConfigRestrictAllTablesPolicyEnforcerThrowWithUnrecognizedPolicy
         ProvisionException.class,
         () -> injector.getInstance(Key.get(PolicyEnforcer.class))
     );
-    Assert.assertTrue(e.getCause().getMessage().contains("Unrecognized policy class"));
+    Assert.assertTrue(e.getCause().getMessage().contains("Unrecognized class[[UnrecognizedPolicy]]"));
   }
 }

From 04814cfe3986e77c72c2c1b32701c5cfb2e64225 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Mon, 7 Apr 2025 18:22:44 -0700
Subject: [PATCH 86/99] Add test for JoinDataSource

---
 .../apache/druid/query/DataSourceTest.java    | 55 ++++++++++++++++++-
 1 file changed, 54 insertions(+), 1 deletion(-)

diff --git a/processing/src/test/java/org/apache/druid/query/DataSourceTest.java b/processing/src/test/java/org/apache/druid/query/DataSourceTest.java
index 52e4c142fb80..7fcec75fca41 100644
--- a/processing/src/test/java/org/apache/druid/query/DataSourceTest.java
+++ b/processing/src/test/java/org/apache/druid/query/DataSourceTest.java
@@ -25,6 +25,7 @@
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
 import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.math.expr.ExprMacroTable;
 import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
 import org.apache.druid.query.dimension.DefaultDimensionSpec;
 import org.apache.druid.query.filter.NullFilter;
@@ -36,6 +37,9 @@
 import org.apache.druid.query.policy.RowFilterPolicy;
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.segment.column.RowSignature;
+import org.apache.druid.segment.join.JoinType;
+import org.apache.druid.segment.join.JoinableFactoryWrapper;
+import org.apache.druid.segment.join.NoopJoinableFactory;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -274,7 +278,6 @@ public void testValidate_onUnionDataSource()
     Assert.assertFalse(unionDataSource.validate(new RestrictAllTablesPolicyEnforcer(ImmutableList.of(
         "NoRestrictionPolicy"))));
 
-
     UnionDataSource unionDataSource2 = new UnionDataSource(Lists.newArrayList(
         RestrictedDataSource.create(
             TableDataSource.create("table1"),
@@ -291,4 +294,54 @@ public void testValidate_onUnionDataSource()
     Assert.assertFalse(unionDataSource2.validate(new RestrictAllTablesPolicyEnforcer(ImmutableList.of(
         "NoRestrictionPolicy"))));
   }
+
+  @Test
+  public void testValidate_onJoinDataSource()
+  {
+    JoinableFactoryWrapper joinableFactoryWrapper = new JoinableFactoryWrapper(NoopJoinableFactory.INSTANCE);
+    JoinDataSource joinDataSource1 = JoinDataSource.create(
+        new TableDataSource("table1"),
+        new TableDataSource("table2"),
+        "j.",
+        "x == \"j.x\"",
+        JoinType.LEFT,
+        null,
+        ExprMacroTable.nil(),
+        joinableFactoryWrapper,
+        JoinAlgorithm.BROADCAST
+    );
+    Assert.assertTrue(joinDataSource1.validate(NoopPolicyEnforcer.instance()));
+    // Fail, policy must exist on both tables
+    Assert.assertFalse(joinDataSource1.validate(new RestrictAllTablesPolicyEnforcer(null)));
+
+    JoinDataSource joinDataSource2 = JoinDataSource.create(
+        RestrictedDataSource.create(new TableDataSource("table1"), NoRestrictionPolicy.instance()),
+        new TableDataSource("table2"),
+        "j.",
+        "x == \"j.x\"",
+        JoinType.LEFT,
+        null,
+        ExprMacroTable.nil(),
+        joinableFactoryWrapper,
+        JoinAlgorithm.BROADCAST
+    );
+    Assert.assertTrue(joinDataSource2.validate(NoopPolicyEnforcer.instance()));
+    // Fail, policy must exist on table
+    Assert.assertFalse(joinDataSource2.validate(new RestrictAllTablesPolicyEnforcer(null)));
+
+    JoinDataSource joinDataSource3 = JoinDataSource.create(
+        RestrictedDataSource.create(new TableDataSource("table1"), NoRestrictionPolicy.instance()),
+        InlineDataSource.fromIterable(ImmutableList.of(), RowSignature.empty()),
+        "j.",
+        "x == \"j.x\"",
+        JoinType.LEFT,
+        null,
+        ExprMacroTable.nil(),
+        joinableFactoryWrapper,
+        JoinAlgorithm.BROADCAST
+    );
+    Assert.assertTrue(joinDataSource3.validate(NoopPolicyEnforcer.instance()));
+    // Success, policy exist on table, and inline data source doesn't need to have policy
+    Assert.assertTrue(joinDataSource3.validate(new RestrictAllTablesPolicyEnforcer(null)));
+  }
 }

From d4088b9dfcf896349f80b840c3bcc9f11cc8327e Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Thu, 10 Apr 2025 16:50:01 -0700
Subject: [PATCH 87/99] add policyEnforcer to withPolicies, and validate
 segment after segment mapping

---
 .../CachingClusteredClientBenchmark.java      |   2 -
 .../benchmark/query/InPlanningBenchmark.java  |   2 +
 .../benchmark/query/SqlBaseBenchmark.java     |   2 +
 .../benchmark/query/SqlVsNativeBenchmark.java |   2 +
 .../movingaverage/MovingAverageQueryTest.java |   2 -
 .../msq/querykit/BaseLeafFrameProcessor.java  |  40 +---
 .../BaseLeafFrameProcessorFactory.java        |   6 +-
 .../querykit/SimpleSegmentMapFnProcessor.java |   8 +-
 .../GroupByPreShuffleFrameProcessor.java      |   3 -
 ...roupByPreShuffleFrameProcessorFactory.java |   1 -
 .../scan/ScanQueryFrameProcessor.java         |   3 -
 .../scan/ScanQueryFrameProcessorFactory.java  |   1 -
 .../druid/msq/sql/MSQTaskQueryMaker.java      |   8 -
 .../controller/http/DartSqlResourceTest.java  |   2 +
 .../msq/exec/ResultsContextSerdeTest.java     |   2 +
 .../scan/ScanQueryFrameProcessorTest.java     | 115 ----------
 .../druid/msq/sql/MSQTaskQueryMakerTest.java  |  14 +-
 .../apache/druid/msq/test/MSQTestBase.java    |   1 +
 .../org/apache/druid/query/DataSource.java    |  33 +--
 .../ReferenceCountingSegmentQueryRunner.java  |  16 +-
 .../druid/query/RestrictedDataSource.java     |   9 +-
 .../apache/druid/query/TableDataSource.java   |  16 +-
 .../druid/query/planning/ExecutionVertex.java |   8 +-
 .../query/policy/NoopPolicyEnforcer.java      |  10 +-
 .../druid/query/policy/PolicyEnforcer.java    |  53 +++--
 .../RestrictAllTablesPolicyEnforcer.java      |  53 +----
 .../segment/ReferenceCountingSegment.java     |  11 +-
 .../druid/segment/RestrictedSegment.java      |   4 +-
 .../druid/segment/SegmentReference.java       |   7 +-
 .../segment/WrappedSegmentReference.java      |   4 +-
 .../druid/segment/join/HashJoinSegment.java   |   4 +-
 .../apache/druid/query/DataSourceTest.java    | 185 ++++++++--------
 .../druid/query/QueryRunnerTestHelper.java    |   3 +-
 .../query/policy/NoopPolicyEnforcerTest.java  |  13 +-
 .../RestrictAllTablesPolicyEnforcerTest.java  |  65 +++---
 .../druid/segment/TestSegmentUtils.java       |  23 +-
 .../druid/client/CachingClusteredClient.java  |  12 -
 .../appenderator/SinkQuerySegmentWalker.java  |   9 +-
 .../druid/server/LocalQuerySegmentWalker.java |   6 +-
 .../apache/druid/server/QueryLifecycle.java   |  11 +-
 .../druid/server/QueryLifecycleFactory.java   |   5 +
 .../server/coordination/ServerManager.java    |  11 +-
 ...chingClusteredClientFunctionalityTest.java |  54 +----
 .../CachingClusteredClientPerfTest.java       |   2 -
 .../client/CachingClusteredClientTest.java    |   2 -
 .../guice/security/PolicyModuleTest.java      |   4 +-
 ...yRunnerBasedOnClusteredClientTestBase.java |   2 -
 .../SegmentMetadataCacheTestBase.java         |   2 +
 .../druid/server/QueryLifecycleTest.java      | 206 ++++++++++++------
 .../druid/server/QueryResourceTest.java       |  15 +-
 .../apache/druid/server/QueryStackTests.java  |   2 +
 .../server/TestClusterQuerySegmentWalker.java |   5 +-
 .../coordination/ServerManagerTest.java       |  18 +-
 .../sql/calcite/planner/PlannerFactory.java   |   3 +
 .../sql/calcite/planner/PlannerToolbox.java   |   9 +
 .../druid/sql/calcite/rel/DruidQuery.java     |   5 +-
 .../apache/druid/sql/SqlStatementTest.java    | 196 +++++++++++++----
 .../sql/avatica/DruidAvaticaHandlerTest.java  |   2 +
 .../druid/sql/avatica/DruidStatementTest.java |   2 +
 .../SqlVectorizedExpressionSanityTest.java    |   2 +
 .../expression/ExpressionTestHelper.java      |   2 +
 .../external/ExternalTableScanRuleTest.java   |   2 +
 .../planner/CalcitePlannerModuleTest.java     |  35 +--
 .../calcite/planner/DruidRexExecutorTest.java |   2 +
 .../sql/calcite/util/QueryFrameworkUtils.java |   2 +
 .../sql/calcite/util/SqlTestFramework.java    |   2 +
 .../druid/sql/http/SqlResourceTest.java       |   2 +
 67 files changed, 668 insertions(+), 695 deletions(-)

diff --git a/benchmarks/src/test/java/org/apache/druid/benchmark/query/CachingClusteredClientBenchmark.java b/benchmarks/src/test/java/org/apache/druid/benchmark/query/CachingClusteredClientBenchmark.java
index 9ce5628b3826..58361aba7538 100644
--- a/benchmarks/src/test/java/org/apache/druid/benchmark/query/CachingClusteredClientBenchmark.java
+++ b/benchmarks/src/test/java/org/apache/druid/benchmark/query/CachingClusteredClientBenchmark.java
@@ -82,7 +82,6 @@
 import org.apache.druid.query.groupby.GroupByStatsProvider;
 import org.apache.druid.query.groupby.GroupingEngine;
 import org.apache.druid.query.groupby.ResultRow;
-import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.spec.MultipleIntervalSegmentSpec;
 import org.apache.druid.query.spec.QuerySegmentSpec;
 import org.apache.druid.query.timeseries.TimeseriesQuery;
@@ -318,7 +317,6 @@ public boolean useParallelMergePool()
         },
         forkJoinPool,
         QueryStackTests.DEFAULT_NOOP_SCHEDULER,
-        NoopPolicyEnforcer.instance(),
         new NoopServiceEmitter()
     );
   }
diff --git a/benchmarks/src/test/java/org/apache/druid/benchmark/query/InPlanningBenchmark.java b/benchmarks/src/test/java/org/apache/druid/benchmark/query/InPlanningBenchmark.java
index f691d2cebecb..6b01d6beb180 100644
--- a/benchmarks/src/test/java/org/apache/druid/benchmark/query/InPlanningBenchmark.java
+++ b/benchmarks/src/test/java/org/apache/druid/benchmark/query/InPlanningBenchmark.java
@@ -33,6 +33,7 @@
 import org.apache.druid.math.expr.ExpressionProcessing;
 import org.apache.druid.query.DruidProcessingConfig;
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.segment.AutoTypeColumnSchema;
 import org.apache.druid.segment.IndexSpec;
 import org.apache.druid.segment.QueryableIndex;
@@ -202,6 +203,7 @@ public void setup() throws JsonProcessingException
         CalciteTests.createJoinableFactoryWrapper(),
         CatalogResolver.NULL_RESOLVER,
         new AuthConfig(),
+        NoopPolicyEnforcer.instance(),
         new DruidHookDispatcher()
     );
 
diff --git a/benchmarks/src/test/java/org/apache/druid/benchmark/query/SqlBaseBenchmark.java b/benchmarks/src/test/java/org/apache/druid/benchmark/query/SqlBaseBenchmark.java
index 05a31dda89d3..7ab942ff6f71 100644
--- a/benchmarks/src/test/java/org/apache/druid/benchmark/query/SqlBaseBenchmark.java
+++ b/benchmarks/src/test/java/org/apache/druid/benchmark/query/SqlBaseBenchmark.java
@@ -60,6 +60,7 @@
 import org.apache.druid.query.aggregation.datasketches.theta.sql.ThetaSketchEstimateOperatorConversion;
 import org.apache.druid.query.aggregation.datasketches.tuple.ArrayOfDoublesSketchModule;
 import org.apache.druid.query.lookup.LookupExtractor;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.segment.IncrementalIndexSegment;
 import org.apache.druid.segment.IndexSpec;
 import org.apache.druid.segment.PhysicalSegmentInspector;
@@ -452,6 +453,7 @@ public static Pair<PlannerFactory, SqlEngine> createSqlSystem(
         new JoinableFactoryWrapper(QueryFrameworkUtils.createDefaultJoinableFactory(injector)),
         CatalogResolver.NULL_RESOLVER,
         new AuthConfig(),
+        NoopPolicyEnforcer.instance(),
         new DruidHookDispatcher()
     );
 
diff --git a/benchmarks/src/test/java/org/apache/druid/benchmark/query/SqlVsNativeBenchmark.java b/benchmarks/src/test/java/org/apache/druid/benchmark/query/SqlVsNativeBenchmark.java
index d9017cb4f28c..1900447fbfaf 100644
--- a/benchmarks/src/test/java/org/apache/druid/benchmark/query/SqlVsNativeBenchmark.java
+++ b/benchmarks/src/test/java/org/apache/druid/benchmark/query/SqlVsNativeBenchmark.java
@@ -32,6 +32,7 @@
 import org.apache.druid.query.dimension.DefaultDimensionSpec;
 import org.apache.druid.query.groupby.GroupByQuery;
 import org.apache.druid.query.groupby.ResultRow;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.segment.QueryableIndex;
 import org.apache.druid.segment.generator.GeneratorBasicSchemas;
 import org.apache.druid.segment.generator.GeneratorSchemaInfo;
@@ -129,6 +130,7 @@ public void setup()
         CalciteTests.createJoinableFactoryWrapper(),
         CatalogResolver.NULL_RESOLVER,
         new AuthConfig(),
+        NoopPolicyEnforcer.instance(),
         new DruidHookDispatcher()
     );
     groupByQuery = GroupByQuery
diff --git a/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageQueryTest.java b/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageQueryTest.java
index 57c671b5984c..dd5f79eecf5d 100644
--- a/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageQueryTest.java
+++ b/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageQueryTest.java
@@ -65,7 +65,6 @@
 import org.apache.druid.query.groupby.GroupByQuery;
 import org.apache.druid.query.groupby.ResultRow;
 import org.apache.druid.query.movingaverage.test.TestConfig;
-import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.timeseries.TimeseriesQuery;
 import org.apache.druid.query.timeseries.TimeseriesResultValue;
 import org.apache.druid.segment.join.MapJoinableFactory;
@@ -366,7 +365,6 @@ public void registerServerRemovedCallback(Executor exec, ServerRemovedCallback c
         new BrokerParallelMergeConfig(),
         ForkJoinPool.commonPool(),
         QueryStackTests.DEFAULT_NOOP_SCHEDULER,
-        NoopPolicyEnforcer.instance(),
         new NoopServiceEmitter()
     );
 
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessor.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessor.java
index 767965dfce68..b3349a9be705 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessor.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessor.java
@@ -21,7 +21,6 @@
 
 import it.unimi.dsi.fastutil.ints.IntSet;
 import org.apache.druid.collections.ResourceHolder;
-import org.apache.druid.error.DruidException;
 import org.apache.druid.frame.channel.ReadableFrameChannel;
 import org.apache.druid.frame.channel.WritableFrameChannel;
 import org.apache.druid.frame.processor.FrameProcessor;
@@ -32,13 +31,8 @@
 import org.apache.druid.java.util.common.Unit;
 import org.apache.druid.msq.exec.DataServerQueryHandler;
 import org.apache.druid.msq.input.ReadableInput;
-import org.apache.druid.msq.input.external.ExternalInputSliceReader;
-import org.apache.druid.msq.input.inline.InlineInputSliceReader;
 import org.apache.druid.msq.input.table.SegmentWithDescriptor;
 import org.apache.druid.msq.input.table.SegmentsInputSlice;
-import org.apache.druid.query.lookup.LookupSegment;
-import org.apache.druid.query.policy.PolicyEnforcer;
-import org.apache.druid.segment.InlineSegmentWrangler;
 import org.apache.druid.segment.ReferenceCountingSegment;
 import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.SegmentReference;
@@ -51,21 +45,18 @@
 public abstract class BaseLeafFrameProcessor implements FrameProcessor<Object>
 {
   private final ReadableInput baseInput;
-  private final PolicyEnforcer policyEnforcer;
   private final ResourceHolder<WritableFrameChannel> outputChannelHolder;
   private final ResourceHolder<FrameWriterFactory> frameWriterFactoryHolder;
   private final Function<SegmentReference, SegmentReference> segmentMapFn;
 
   protected BaseLeafFrameProcessor(
       final ReadableInput baseInput,
-      final PolicyEnforcer policyEnforcer,
       final Function<SegmentReference, SegmentReference> segmentMapFn,
       final ResourceHolder<WritableFrameChannel> outputChannelHolder,
       final ResourceHolder<FrameWriterFactory> frameWriterFactoryHolder
   )
   {
     this.baseInput = baseInput;
-    this.policyEnforcer = policyEnforcer;
     this.outputChannelHolder = outputChannelHolder;
     this.frameWriterFactoryHolder = frameWriterFactoryHolder;
     this.segmentMapFn = segmentMapFn;
@@ -128,8 +119,7 @@ protected FrameWriterFactory getFrameWriterFactory()
    * Runs the leaf processor using the results from a data server as the input. The query and data server details are
    * described by {@link DataServerQueryHandler}.
    */
-  protected abstract ReturnOrAwait<SegmentsInputSlice> runWithDataServerQuery(DataServerQueryHandler dataServerQueryHandler)
-      throws IOException;
+  protected abstract ReturnOrAwait<SegmentsInputSlice> runWithDataServerQuery(DataServerQueryHandler dataServerQueryHandler) throws IOException;
 
   protected abstract ReturnOrAwait<Unit> runWithInputChannel(
       ReadableFrameChannel inputChannel,
@@ -142,32 +132,6 @@ protected abstract ReturnOrAwait<Unit> runWithInputChannel(
    */
   protected SegmentReference mapSegment(final Segment segment)
   {
-    SegmentReference mappedSegment = segmentMapFn.apply(ReferenceCountingSegment.wrapRootGenerationSegment(segment));
-    if (segment instanceof LookupSegment) {
-      return mappedSegment;
-    }
-    return validateMappedSegment(mappedSegment);
-  }
-
-  private SegmentReference validateMappedSegment(SegmentReference mappedSegment)
-  {
-    switch (mappedSegment.getId().getDataSource()) {
-      case InlineSegmentWrangler.SEGMENT_ID:
-      case InlineInputSliceReader.SEGMENT_ID:
-      case ExternalInputSliceReader.SEGMENT_ID:
-        return mappedSegment;
-      default:
-        // continue
-    }
-    if (mappedSegment.validate(policyEnforcer)) {
-      return mappedSegment;
-    }
-    throw DruidException.forPersona(DruidException.Persona.OPERATOR)
-                        .ofCategory(DruidException.Category.FORBIDDEN)
-                        .build(
-                            "Failed security validation with segment [%s] type [%s]",
-                            mappedSegment.getId(),
-                            mappedSegment.getClass()
-                        );
+    return segmentMapFn.apply(ReferenceCountingSegment.wrapRootGenerationSegment(segment));
   }
 }
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessorFactory.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessorFactory.java
index d35b3cf67221..cb72f80396c9 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessorFactory.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessorFactory.java
@@ -162,8 +162,8 @@ public ProcessorsAndChannels<Object, Long> makeProcessors(
     final ProcessorManager processorManager;
 
     if (segmentMapFnProcessor == null) {
-      final Function<SegmentReference, SegmentReference> segmentMapFn =
-          query.getDataSource().createSegmentMapFunction(query);
+      final Function<SegmentReference, SegmentReference> segmentMapFn = ExecutionVertex.of(query)
+                                                                                       .createSegmentMapFunction(frameContext.policyEnforcer());
       processorManager = processorManagerFn.apply(ImmutableList.of(segmentMapFn));
     } else {
       processorManager = new ChainedProcessorManager<>(ProcessorManagers.of(() -> segmentMapFnProcessor), processorManagerFn);
@@ -342,7 +342,7 @@ private FrameProcessor<Function<SegmentReference, SegmentReference>> makeSegment
     if (broadcastInputs.isEmpty()) {
       if (ExecutionVertex.of(query).isSegmentMapFunctionExpensive()) {
         // Joins may require significant computation to compute the segmentMapFn. Offload it to a processor.
-        return new SimpleSegmentMapFnProcessor(query);
+        return new SimpleSegmentMapFnProcessor(query, frameContext.policyEnforcer());
       } else {
         // Non-joins are expected to have cheap-to-compute segmentMapFn. Do the computation in the factory thread,
         // without offloading to a processor.
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/SimpleSegmentMapFnProcessor.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/SimpleSegmentMapFnProcessor.java
index 54264d379c93..54a0065d1994 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/SimpleSegmentMapFnProcessor.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/SimpleSegmentMapFnProcessor.java
@@ -26,6 +26,7 @@
 import org.apache.druid.frame.processor.ReturnOrAwait;
 import org.apache.druid.query.Query;
 import org.apache.druid.query.planning.ExecutionVertex;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.SegmentReference;
 
 import java.util.Collections;
@@ -44,10 +45,13 @@
 public class SimpleSegmentMapFnProcessor implements FrameProcessor<Function<SegmentReference, SegmentReference>>
 {
   private final Query<?> query;
+  private final PolicyEnforcer policyEnforcer;
 
-  public SimpleSegmentMapFnProcessor(final Query<?> query)
+  public SimpleSegmentMapFnProcessor(final Query<?> query,
+                                     final PolicyEnforcer policyEnforcer)
   {
     this.query = query;
+    this.policyEnforcer = policyEnforcer;
   }
 
   @Override
@@ -66,7 +70,7 @@ public List<WritableFrameChannel> outputChannels()
   public ReturnOrAwait<Function<SegmentReference, SegmentReference>> runIncrementally(final IntSet readableInputs)
   {
     ExecutionVertex ev = ExecutionVertex.of(query);
-    return ReturnOrAwait.returnObject(ev.createSegmentMapFunction());
+    return ReturnOrAwait.returnObject(ev.createSegmentMapFunction(policyEnforcer));
   }
 
   @Override
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/groupby/GroupByPreShuffleFrameProcessor.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/groupby/GroupByPreShuffleFrameProcessor.java
index d636385a84f2..ad456a45f5b1 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/groupby/GroupByPreShuffleFrameProcessor.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/groupby/GroupByPreShuffleFrameProcessor.java
@@ -51,7 +51,6 @@
 import org.apache.druid.query.groupby.GroupingEngine;
 import org.apache.druid.query.groupby.ResultRow;
 import org.apache.druid.query.groupby.epinephelinae.RowBasedGrouperHelper;
-import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.query.spec.MultipleIntervalSegmentSpec;
 import org.apache.druid.query.spec.SpecificSegmentSpec;
 import org.apache.druid.segment.ColumnSelectorFactory;
@@ -89,7 +88,6 @@ public GroupByPreShuffleFrameProcessor(
       final GroupByQuery query,
       final GroupingEngine groupingEngine,
       final NonBlockingPool<ByteBuffer> bufferPool,
-      final PolicyEnforcer policyEnforcer,
       final ReadableInput baseInput,
       final Function<SegmentReference, SegmentReference> segmentMapFn,
       final ResourceHolder<WritableFrameChannel> outputChannelHolder,
@@ -98,7 +96,6 @@ public GroupByPreShuffleFrameProcessor(
   {
     super(
         baseInput,
-        policyEnforcer,
         segmentMapFn,
         outputChannelHolder,
         frameWriterFactoryHolder
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/groupby/GroupByPreShuffleFrameProcessorFactory.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/groupby/GroupByPreShuffleFrameProcessorFactory.java
index 38155b4d6232..5ae163c1fd0d 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/groupby/GroupByPreShuffleFrameProcessorFactory.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/groupby/GroupByPreShuffleFrameProcessorFactory.java
@@ -66,7 +66,6 @@ protected FrameProcessor<Object> makeProcessor(
         query,
         frameContext.groupingEngine(),
         frameContext.processingBuffers().getBufferPool(),
-        frameContext.policyEnforcer(),
         baseInput,
         segmentMapFn,
         outputChannelHolder,
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessor.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessor.java
index 20a5c67101d1..1be191bddbe6 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessor.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessor.java
@@ -62,7 +62,6 @@
 import org.apache.druid.query.Druids;
 import org.apache.druid.query.IterableRowsCursorHelper;
 import org.apache.druid.query.Order;
-import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.query.scan.ScanQuery;
 import org.apache.druid.query.scan.ScanQueryEngine;
 import org.apache.druid.query.scan.ScanResultValue;
@@ -117,7 +116,6 @@ public ScanQueryFrameProcessor(
       final ScanQuery query,
       @Nullable final AtomicLong runningCountForLimit,
       final ObjectMapper jsonMapper,
-      final PolicyEnforcer policyEnforcer,
       final ReadableInput baseInput,
       final Function<SegmentReference, SegmentReference> segmentMapFn,
       final ResourceHolder<WritableFrameChannel> outputChannelHolder,
@@ -126,7 +124,6 @@ public ScanQueryFrameProcessor(
   {
     super(
         baseInput,
-        policyEnforcer,
         segmentMapFn,
         outputChannelHolder,
         frameWriterFactoryHolder
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorFactory.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorFactory.java
index 1d73f3c08e87..1636e1177406 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorFactory.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorFactory.java
@@ -78,7 +78,6 @@ protected FrameProcessor<Object> makeProcessor(
         query,
         runningCountForLimit,
         frameContext.jsonMapper(),
-        frameContext.policyEnforcer(),
         baseInput,
         segmentMapFn,
         outputChannelHolder,
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java
index 5bd49dc42274..d50bace8dda0 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java
@@ -128,14 +128,6 @@ public QueryResponse<Object[]> runQuery(final DruidQuery druidQuery)
   {
     Hook.QUERY_PLAN.run(druidQuery.getQuery());
     plannerContext.dispatchHook(DruidHook.NATIVE_PLAN, druidQuery.getQuery());
-    if (!druidQuery.getQuery().getDataSource().validate(policyEnforcer)) {
-      throw DruidException.forPersona(DruidException.Persona.OPERATOR)
-                          .ofCategory(DruidException.Category.FORBIDDEN)
-                          .build(
-                              "Failed security validation with dataSource [%s]",
-                              druidQuery.getQuery().getDataSource()
-                          );
-    }
 
     String taskId = MSQTasks.controllerTaskId(plannerContext.getSqlQueryId());
 
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/dart/controller/http/DartSqlResourceTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/dart/controller/http/DartSqlResourceTest.java
index 10b5f20e4187..c0608339bed0 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/dart/controller/http/DartSqlResourceTest.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/dart/controller/http/DartSqlResourceTest.java
@@ -51,6 +51,7 @@
 import org.apache.druid.query.DefaultQueryConfig;
 import org.apache.druid.query.QueryContext;
 import org.apache.druid.query.QueryContexts;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.server.DruidNode;
 import org.apache.druid.server.QueryStackTests;
 import org.apache.druid.server.ResponseContextConfig;
@@ -215,6 +216,7 @@ public void register(ControllerHolder holder)
         CalciteTests.createJoinableFactoryWrapper(),
         CatalogResolver.NULL_RESOLVER,
         new AuthConfig(),
+        NoopPolicyEnforcer.instance(),
         new DruidHookDispatcher()
     );
 
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/ResultsContextSerdeTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/ResultsContextSerdeTest.java
index 72f2c8176223..084bf8e92fff 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/ResultsContextSerdeTest.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/ResultsContextSerdeTest.java
@@ -29,6 +29,7 @@
 import org.apache.druid.jackson.DefaultObjectMapper;
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
 import org.apache.druid.query.QuerySegmentWalker;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.server.security.AuthConfig;
 import org.apache.druid.sql.calcite.planner.CalciteRulesManager;
 import org.apache.druid.sql.calcite.planner.CatalogResolver;
@@ -77,6 +78,7 @@ NamedViewSchema.NAME, new NamedViewSchema(EasyMock.createMock(ViewSchema.class))
         new CalciteRulesManager(ImmutableSet.of()),
         CalciteTests.TEST_AUTHORIZER_MAPPER,
         AuthConfig.newBuilder().build(),
+        NoopPolicyEnforcer.instance(),
         new DruidHookDispatcher()
     );
     final NativeSqlEngine engine = CalciteTests.createMockSqlEngine(
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorTest.java
index c0dae92f753d..21e3707f00fd 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorTest.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/scan/ScanQueryFrameProcessorTest.java
@@ -47,23 +47,14 @@
 import org.apache.druid.msq.kernel.StagePartition;
 import org.apache.druid.msq.querykit.FrameProcessorTestBase;
 import org.apache.druid.msq.test.LimitedFrameWriterFactory;
-import org.apache.druid.query.DataSource;
 import org.apache.druid.query.Druids;
-import org.apache.druid.query.RestrictedDataSource;
-import org.apache.druid.query.TableDataSource;
-import org.apache.druid.query.policy.NoRestrictionPolicy;
-import org.apache.druid.query.policy.NoopPolicyEnforcer;
-import org.apache.druid.query.policy.PolicyEnforcer;
-import org.apache.druid.query.policy.RestrictAllTablesPolicyEnforcer;
 import org.apache.druid.query.scan.ScanQuery;
 import org.apache.druid.query.spec.MultipleIntervalSegmentSpec;
-import org.apache.druid.query.spec.QuerySegmentSpec;
 import org.apache.druid.segment.CompleteSegment;
 import org.apache.druid.segment.CursorFactory;
 import org.apache.druid.segment.QueryableIndex;
 import org.apache.druid.segment.QueryableIndexCursorFactory;
 import org.apache.druid.segment.QueryableIndexSegment;
-import org.apache.druid.segment.SegmentReference;
 import org.apache.druid.segment.TestIndex;
 import org.apache.druid.segment.column.RowSignature;
 import org.apache.druid.segment.incremental.IncrementalIndexCursorFactory;
@@ -71,7 +62,6 @@
 import org.hamcrest.CoreMatchers;
 import org.hamcrest.MatcherAssert;
 import org.junit.Assert;
-import org.junit.Before;
 import org.junit.Test;
 import org.junit.internal.matchers.ThrowableMessageMatcher;
 
@@ -82,33 +72,6 @@
 
 public class ScanQueryFrameProcessorTest extends FrameProcessorTestBase
 {
-  private CursorFactory cursorFactory;
-  private ReadableInput baseInput;
-  private FrameWriterFactory frameWriterFactory;
-  private BlockingQueueFrameChannel outputChannel;
-
-  @Override
-  @Before
-  public void setUp() throws Exception
-  {
-    final QueryableIndex queryableIndex = TestIndex.getMMappedTestIndex();
-    cursorFactory = new QueryableIndexCursorFactory(queryableIndex);
-    baseInput = makeChannelFromCursorFactory(cursorFactory, ImmutableList.of(), 1000);
-
-    // Limit output frames to 1 row to ensure we test edge cases
-    frameWriterFactory = new LimitedFrameWriterFactory(
-        FrameWriters.makeRowBasedFrameWriterFactory(
-            new SingleMemoryAllocatorFactory(HeapMemoryAllocator.unlimited()),
-            new QueryableIndexCursorFactory(queryableIndex).getRowSignature(),
-            Collections.emptyList(),
-            false
-        ),
-        1
-    );
-    outputChannel = BlockingQueueFrameChannel.minimal();
-
-    super.setUp();
-  }
 
   @Test
   public void test_runWithSegments() throws Exception
@@ -150,7 +113,6 @@ public void test_runWithSegments() throws Exception
         query,
         null,
         new DefaultObjectMapper(),
-        NoopPolicyEnforcer.instance(),
         ReadableInput.segment(
             new SegmentWithDescriptor(
                 () -> new StupidResourceHolder<>(new CompleteSegment(null, new QueryableIndexSegment(queryableIndex, SegmentId.dummy("test")))),
@@ -250,7 +212,6 @@ public void test_runWithInputChannel() throws Exception
         query,
         null,
         new DefaultObjectMapper(),
-        NoopPolicyEnforcer.instance(),
         ReadableInput.channel(inputChannel.readable(), FrameReader.create(signature), stagePartition),
         Function.identity(),
         new ResourceHolder<>()
@@ -294,80 +255,4 @@ public void close()
             + "2011-01-02T00:00:00.000Z/2021-01-01T00:00:00.000Z]]"))
     );
   }
-
-  @Test
-  public void test_runWithPolicyEnforcerThrowsOnValidationFailure() throws Exception
-  {
-    // Arrange
-    QuerySegmentSpec querySegmentSpec = new MultipleIntervalSegmentSpec(Intervals.ONLY_ETERNITY);
-    DataSource dataSource = TableDataSource.create("test");
-    ScanQuery query =
-        Druids.newScanQueryBuilder()
-              .dataSource(dataSource)
-              .intervals(querySegmentSpec)
-              .columns(cursorFactory.getRowSignature().getColumnNames())
-              .build();
-    Function<SegmentReference, SegmentReference> mapFn = dataSource.createSegmentMapFunction(query);
-
-    PolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
-    final ScanQueryFrameProcessor processor = new ScanQueryFrameProcessor(
-        query,
-        null,
-        new DefaultObjectMapper(),
-        policyEnforcer,
-        baseInput,
-        mapFn,
-        ResourceHolder.fromCloseable(outputChannel.writable()),
-        new ReferenceCountingResourceHolder<>(frameWriterFactory, () -> {
-        })
-    );
-    // Act
-    exec.runFully(processor, null);
-    final Sequence<List<Object>> rowsFromProcessor = FrameTestUtil.readRowsFromFrameChannel(
-        outputChannel.readable(),
-        FrameReader.create(cursorFactory.getRowSignature())
-    );
-    // Assert
-    Exception e = Assert.assertThrows(Exception.class, () -> rowsFromProcessor.toList());
-    Assert.assertTrue(e.getCause().getMessage().contains("Failed security validation"));
-  }
-
-  @Test
-  public void test_runWithPolicyEnforcerPassedValidation() throws Exception
-  {
-    // Arrange
-    QuerySegmentSpec querySegmentSpec = new MultipleIntervalSegmentSpec(Intervals.ONLY_ETERNITY);
-    DataSource dataSource = RestrictedDataSource.create(TableDataSource.create("test"), NoRestrictionPolicy.instance());
-    ScanQuery query =
-        Druids.newScanQueryBuilder()
-              .dataSource(dataSource)
-              .intervals(querySegmentSpec)
-              .columns(cursorFactory.getRowSignature().getColumnNames())
-              .build();
-    Function<SegmentReference, SegmentReference> mapFn = dataSource.createSegmentMapFunction(query);
-
-    PolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
-    final ScanQueryFrameProcessor processor = new ScanQueryFrameProcessor(
-        query,
-        null,
-        new DefaultObjectMapper(),
-        policyEnforcer,
-        baseInput,
-        mapFn,
-        ResourceHolder.fromCloseable(outputChannel.writable()),
-        new ReferenceCountingResourceHolder<>(frameWriterFactory, () -> {
-        })
-    );
-    // Act
-    exec.runFully(processor, null);
-    final Sequence<List<Object>> rowsFromProcessorOnRestricted = FrameTestUtil.readRowsFromFrameChannel(
-        outputChannel.readable(),
-        FrameReader.create(cursorFactory.getRowSignature())
-    );
-    // Assert
-    FrameTestUtil.assertRowsEqual(
-        FrameTestUtil.readRowsFromCursorFactory(cursorFactory, cursorFactory.getRowSignature(), false),
-        rowsFromProcessorOnRestricted
-    );
-  }
 }
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
index 50dfef8c9d5c..f4bd42b98569 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
@@ -31,7 +31,6 @@
 import com.google.inject.util.Modules;
 import org.apache.calcite.jdbc.JavaTypeFactoryImpl;
 import org.apache.druid.collections.ReferenceCountingResourceHolder;
-import org.apache.druid.error.DruidException;
 import org.apache.druid.guice.ConfigModule;
 import org.apache.druid.guice.DruidGuiceExtensions;
 import org.apache.druid.guice.DruidSecondaryModule;
@@ -46,6 +45,7 @@
 import org.apache.druid.msq.exec.DataServerQueryHandlerFactory;
 import org.apache.druid.msq.indexing.destination.MSQTerminalStageSpecFactory;
 import org.apache.druid.msq.indexing.destination.SegmentGenerationTerminalStageSpecFactory;
+import org.apache.druid.msq.indexing.error.MSQErrorReport;
 import org.apache.druid.msq.indexing.report.MSQTaskReport;
 import org.apache.druid.msq.indexing.report.MSQTaskReportPayload;
 import org.apache.druid.msq.querykit.DataSegmentProvider;
@@ -278,9 +278,17 @@ public void testScanQueryFailWithPolicyValidation() throws Exception
         fieldMapping,
         terminalStageSpecFactory
     );
+    QueryResponse<Object[]> response = msqTaskQueryMaker.runQuery(druidQueryMock);
+    // Assert
+    String taskId = (String) Iterables.getOnlyElement(response.getResults().toList())[0];
+    MSQTaskReportPayload payload = (MSQTaskReportPayload) fakeOverlordClient.taskReportAsMap(taskId)
+                                                                            .get()
+                                                                            .get(MSQTaskReport.REPORT_KEY)
+                                                                            .getPayload();
     // Assert
-    DruidException e = Assert.assertThrows(DruidException.class, () -> msqTaskQueryMaker.runQuery(druidQueryMock));
-    Assert.assertTrue(e.getMessage().contains("Failed security validation with dataSource [foo]"));
+    Assert.assertTrue(payload.getStatus().getStatus().isFailure());
+    MSQErrorReport errorReport = payload.getStatus().getErrorReport();
+    Assert.assertTrue(errorReport.getFault().getErrorMessage().contains("Failed security validation with segment"));
   }
 
   @Test
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestBase.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestBase.java
index 5db75e7fec66..1247a8e60cac 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestBase.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestBase.java
@@ -591,6 +591,7 @@ public String getFormatString()
         CalciteTests.createJoinableFactoryWrapper(),
         catalogResolver,
         new AuthConfig(),
+        NoopPolicyEnforcer.instance(),
         new DruidHookDispatcher()
     );
 
diff --git a/processing/src/main/java/org/apache/druid/query/DataSource.java b/processing/src/main/java/org/apache/druid/query/DataSource.java
index 9c259fedd3da..3e36cf0c1f0a 100644
--- a/processing/src/main/java/org/apache/druid/query/DataSource.java
+++ b/processing/src/main/java/org/apache/druid/query/DataSource.java
@@ -28,7 +28,6 @@
 import org.apache.druid.segment.SegmentReference;
 
 import javax.annotation.Nullable;
-
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -84,9 +83,9 @@ public interface DataSource extends Cacheable
 
   /**
    * Decides if this datasource can be accessed globally.
-   *
+   * <p>
    * This means that all servers have a full copy of this datasource.
-   *
+   * <p>
    * Examples: inline table, lookup.
    */
   boolean isGlobal();
@@ -95,7 +94,7 @@ public interface DataSource extends Cacheable
    * Communicates that this {@link DataSource} can be directly used to run a {@link Query}.
    * <p>
    * A Processable datasource must pack the necessary logic into the {@link DataSource#createSegmentMapFunction(Query)}.
-   *
+   * <p>
    * Processable examples are: {@link TableDataSource}, {@link InlineDataSource}, {@link FilteredDataSource}.
    * Non-processable ones are those which need further pre-processing before running them.
    * examples are: {@link QueryDataSource} and join which are not supported directly.
@@ -112,36 +111,26 @@ public interface DataSource extends Cacheable
    * <p>
    * If this datasource contains no table, no changes should occur.
    *
-   * @param policyMap a mapping of table names to policy restrictions. A missing key is different from an empty value:
-   *                  <ul>
-   *                    <li> a missing key means the table has never been permission checked.
-   *                    <li> an empty value indicates the table doesn't have any policy restrictions, it has been permission checked.
+   * @param policyMap      a mapping of table names to policy restrictions. A missing key is different from an empty value:
+   *                       <ul>
+   *                         <li> a missing key means the table has never been permission checked.
+   *                         <li> an empty value indicates the table doesn't have any policy restrictions, it has been permission checked.
+   *                       </ul>
+   * @param policyEnforcer the policy enforcer to enforce the result datasource complies
    * @return the updated datasource, with restrictions applied in the datasource tree
    * @throws IllegalStateException when mapping a RestrictedDataSource, unless the table has a NoRestrictionPolicy in
    *                               the policyMap (used by druid-internal). Missing policy or adding a
    *                               non-NoRestrictionPolicy to RestrictedDataSource would throw.
    */
-  default DataSource withPolicies(Map<String, Optional<Policy>> policyMap)
+  default DataSource withPolicies(Map<String, Optional<Policy>> policyMap, PolicyEnforcer policyEnforcer)
   {
     List<DataSource> children = this.getChildren()
                                     .stream()
-                                    .map(child -> child.withPolicies(policyMap))
+                                    .map(child -> child.withPolicies(policyMap, policyEnforcer))
                                     .collect(Collectors.toList());
     return this.withChildren(children);
   }
 
-  /**
-   * Returns true if the datasource complies with the policy restrictions on tables.
-   * <p>
-   * This should be called right before the data source is about to be processed by the query stack.
-   */
-  default boolean validate(PolicyEnforcer policyEnforcer)
-  {
-    return this.getChildren()
-               .stream()
-               .allMatch(child -> child.validate(policyEnforcer));
-  }
-
   /**
    * Compute a cache key prefix for a data source. This includes the data sources that participate in the RHS of a
    * join as well as any query specific constructs associated with join data source such as base table filter. This key prefix
diff --git a/processing/src/main/java/org/apache/druid/query/ReferenceCountingSegmentQueryRunner.java b/processing/src/main/java/org/apache/druid/query/ReferenceCountingSegmentQueryRunner.java
index a88de6e4d046..a92bbd6421b7 100644
--- a/processing/src/main/java/org/apache/druid/query/ReferenceCountingSegmentQueryRunner.java
+++ b/processing/src/main/java/org/apache/druid/query/ReferenceCountingSegmentQueryRunner.java
@@ -19,11 +19,9 @@
 
 package org.apache.druid.query;
 
-import org.apache.druid.error.DruidException;
 import org.apache.druid.java.util.common.guava.Sequence;
 import org.apache.druid.java.util.common.guava.Sequences;
 import org.apache.druid.query.context.ResponseContext;
-import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.SegmentReference;
 
 public class ReferenceCountingSegmentQueryRunner<T> implements QueryRunner<T>
@@ -31,33 +29,21 @@ public class ReferenceCountingSegmentQueryRunner<T> implements QueryRunner<T>
   private final QueryRunnerFactory<T, Query<T>> factory;
   private final SegmentReference segment;
   private final SegmentDescriptor descriptor;
-  private final PolicyEnforcer policyEnforcer;
 
   public ReferenceCountingSegmentQueryRunner(
       QueryRunnerFactory<T, Query<T>> factory,
       SegmentReference segment,
-      SegmentDescriptor descriptor,
-      PolicyEnforcer policyEnforcer
+      SegmentDescriptor descriptor
   )
   {
     this.factory = factory;
     this.segment = segment;
     this.descriptor = descriptor;
-    this.policyEnforcer = policyEnforcer;
   }
 
   @Override
   public Sequence<T> run(final QueryPlus<T> queryPlus, ResponseContext responseContext)
   {
-    if (!segment.validate(policyEnforcer)) {
-      throw DruidException.forPersona(DruidException.Persona.OPERATOR)
-                          .ofCategory(DruidException.Category.FORBIDDEN)
-                          .build(
-                              "Failed security validation with segment [%s] and type [%s]",
-                              segment.getId(),
-                              segment.getClass()
-                          );
-    }
     return segment.acquireReferences().map(closeable -> {
       try {
         final Sequence<T> baseSequence = factory.createRunner(segment).run(queryPlus, responseContext);
diff --git a/processing/src/main/java/org/apache/druid/query/RestrictedDataSource.java b/processing/src/main/java/org/apache/druid/query/RestrictedDataSource.java
index 7892539a0219..74f6b3ed87f7 100644
--- a/processing/src/main/java/org/apache/druid/query/RestrictedDataSource.java
+++ b/processing/src/main/java/org/apache/druid/query/RestrictedDataSource.java
@@ -130,7 +130,7 @@ public Function<SegmentReference, SegmentReference> createSegmentMapFunction(Que
   }
 
   @Override
-  public DataSource withPolicies(Map<String, Optional<Policy>> policyMap)
+  public DataSource withPolicies(Map<String, Optional<Policy>> policyMap, PolicyEnforcer policyEnforcer)
   {
     if (!policyMap.containsKey(base.getName())) {
       throw new ISE("Missing policy check result for table [%s]", base.getName());
@@ -158,15 +158,10 @@ public DataSource withPolicies(Map<String, Optional<Policy>> policyMap)
     }
     // The only happy path is, newPolicy is NoRestrictionPolicy, which means this comes from an anthenticated and
     // authorized druid-internal request.
+    policyEnforcer.validateOrElseThrow(base, policy);
     return this;
   }
 
-  @Override
-  public boolean validate(PolicyEnforcer policyEnforcer)
-  {
-    return policyEnforcer.validate(this, policy);
-  }
-
   @Override
   public String toString()
   {
diff --git a/processing/src/main/java/org/apache/druid/query/TableDataSource.java b/processing/src/main/java/org/apache/druid/query/TableDataSource.java
index 0204076444da..e0aa1332e5f2 100644
--- a/processing/src/main/java/org/apache/druid/query/TableDataSource.java
+++ b/processing/src/main/java/org/apache/druid/query/TableDataSource.java
@@ -81,21 +81,11 @@ public boolean isProcessable()
   }
 
   @Override
-  public DataSource withPolicies(Map<String, Optional<Policy>> policyMap)
+  public DataSource withPolicies(Map<String, Optional<Policy>> policyMap, PolicyEnforcer policyEnforcer)
   {
     Optional<Policy> policy = policyMap.getOrDefault(name, Optional.empty());
-    if (policy.isEmpty()) {
-      // Skip adding restriction on table if there's no policy restriction found.
-      return this;
-    }
-    return RestrictedDataSource.create(this, policy.get());
-  }
-
-  @Override
-  public boolean validate(PolicyEnforcer policyEnforcer)
-  {
-    // If it reaches here, this table is not wrapped with a RestrictedDataSource (which should overwrite this method).
-    return policyEnforcer.validate(this, null);
+    policyEnforcer.validateOrElseThrow(this, policy.orElse(null));
+    return policy.isEmpty() ? this : RestrictedDataSource.create(this, policy.get());
   }
 
   @Override
diff --git a/processing/src/main/java/org/apache/druid/query/planning/ExecutionVertex.java b/processing/src/main/java/org/apache/druid/query/planning/ExecutionVertex.java
index 5a4df92bbd72..b8d750ef1666 100644
--- a/processing/src/main/java/org/apache/druid/query/planning/ExecutionVertex.java
+++ b/processing/src/main/java/org/apache/druid/query/planning/ExecutionVertex.java
@@ -31,6 +31,7 @@
 import org.apache.druid.query.QueryToolChest;
 import org.apache.druid.query.TableDataSource;
 import org.apache.druid.query.UnionDataSource;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.query.scan.ScanQuery;
 import org.apache.druid.query.spec.MultipleIntervalSegmentSpec;
 import org.apache.druid.query.spec.QuerySegmentSpec;
@@ -392,10 +393,13 @@ public int hashCode()
   /**
    * Assembles the segment mapping function which should be applied to the input segments.
    */
-  public Function<SegmentReference, SegmentReference> createSegmentMapFunction()
+  public Function<SegmentReference, SegmentReference> createSegmentMapFunction(PolicyEnforcer policyEnforcer)
   {
     DataSource topDataSource = getTopDataSource();
-    return topDataSource.createSegmentMapFunction(topQuery);
+    return topDataSource.createSegmentMapFunction(topQuery).andThen(segmentReference -> {
+      segmentReference.validateOrElseThrow(policyEnforcer);
+      return segmentReference;
+    });
   }
 
   /**
diff --git a/processing/src/main/java/org/apache/druid/query/policy/NoopPolicyEnforcer.java b/processing/src/main/java/org/apache/druid/query/policy/NoopPolicyEnforcer.java
index 578dbcc1ac2d..b62b505a24d7 100644
--- a/processing/src/main/java/org/apache/druid/query/policy/NoopPolicyEnforcer.java
+++ b/processing/src/main/java/org/apache/druid/query/policy/NoopPolicyEnforcer.java
@@ -20,8 +20,6 @@
 package org.apache.druid.query.policy;
 
 import com.fasterxml.jackson.annotation.JsonCreator;
-import org.apache.druid.query.DataSource;
-import org.apache.druid.segment.SegmentReference;
 
 /**
  * Allows all data sources (no restrictions).
@@ -33,13 +31,7 @@ public class NoopPolicyEnforcer implements PolicyEnforcer
   }
 
   @Override
-  public boolean validate(DataSource unused, Policy unused2)
-  {
-    return true;
-  }
-
-  @Override
-  public boolean validate(SegmentReference unused, Policy unused2)
+  public boolean validate(Policy unused)
   {
     return true;
   }
diff --git a/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java b/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
index 66627972b07b..26d4bc4e1d28 100644
--- a/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
+++ b/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
@@ -21,8 +21,10 @@
 
 import com.fasterxml.jackson.annotation.JsonSubTypes;
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import org.apache.druid.error.DruidException;
 import org.apache.druid.guice.annotations.UnstableApi;
 import org.apache.druid.query.DataSource;
+import org.apache.druid.query.TableDataSource;
 import org.apache.druid.segment.SegmentReference;
 
 /**
@@ -41,30 +43,49 @@
 @UnstableApi
 public interface PolicyEnforcer
 {
-
   /**
-   * Validates a {@link DataSource} against the policy enforcer. This method is invoked before query execution
-   * via {@link DataSource#validate(PolicyEnforcer)}. The callsite must ensure that the data source is not a composite
-   * tree, and it must be a druid table. Specifically, it must be one of TableDataSource and RestrictedTableDataSource.
-   * <p>
-   * Direct invocation of this method is discouraged; use {@link DataSource#validate(PolicyEnforcer)} instead.
+   * Validates a {@link DataSource} against the policy enforcer. Prior to query execution, the {@link org.apache.druid.query.Query#getDataSource()}
+   * tree is walked. This method is invoked once for each {@link org.apache.druid.query.RestrictedDataSource} and once
+   * for each {@link TableDataSource} that is not wrapped inside a {@link org.apache.druid.query.RestrictedDataSource},
+   * no matter where they appear within the tree.
    *
-   * @param ds     the data source to validate
-   * @param policy the policy on the data source, e.x. {@link org.apache.druid.query.RestrictedDataSource#policy} or null for {@link org.apache.druid.query.TableDataSource}
-   * @return {@code true} if the data source complies with the policy, {@code false} otherwise
+   * @param ds     the data source to validate. Always {@link TableDataSource}.
+   * @param policy the policy attached to the table; either {@link org.apache.druid.query.RestrictedDataSource#policy} or null.
+   * @throws DruidException if the data source does not comply with the policy
    */
-  boolean validate(DataSource ds, Policy policy);
+  default void validateOrElseThrow(TableDataSource ds, Policy policy) throws DruidException
+  {
+    if (validate(policy)) {
+      return;
+    }
+    throw DruidException.forPersona(DruidException.Persona.OPERATOR)
+                        .ofCategory(DruidException.Category.FORBIDDEN)
+                        .build("Failed security validation with dataSource [%s]", ds);
+  }
 
   /**
-   * Validates a {@link SegmentReference} against the policy enforcer. This method is invoked before query execution
-   * via {@link SegmentReference#validate(PolicyEnforcer)}. The callsite must ensure that the segment reference is not a
-   * deeply linked segment reference, and it must be referenced to a druid table.
+   * Validates a {@link SegmentReference} against the policy enforcer. This method is invoked during query execution via
+   * {@link SegmentReference#validateOrElseThrow(PolicyEnforcer)}. The callsite must ensure that the segment reference
+   * is not a deeply linked segment reference, and it must be referenced to a druid table.
    * <p>
-   * Direct invocation of this method is discouraged; use {@link SegmentReference#validate(PolicyEnforcer)} instead.
+   * Direct invocation of this method is discouraged; use {@link SegmentReference#validateOrElseThrow(PolicyEnforcer)} instead.
    *
    * @param segment the segment to validate
    * @param policy  the policy on the segment, {@link org.apache.druid.segment.RestrictedSegment#policy} or null for other
-   * @return {@code true} if the segment complies with the policy, {@code false} otherwise
+   * @throws DruidException if the segment does not comply with the policy
+   */
+  default void validateOrElseThrow(SegmentReference segment, Policy policy) throws DruidException
+  {
+    if (validate(policy)) {
+      return;
+    }
+    throw DruidException.forPersona(DruidException.Persona.OPERATOR)
+                        .ofCategory(DruidException.Category.FORBIDDEN)
+                        .build("Failed security validation with segment [%s]", segment.getId());
+  }
+
+  /**
+   * Returns true if the policy complies with the policy enforcer.
    */
-  boolean validate(SegmentReference segment, Policy policy);
+  boolean validate(Policy policy);
 }
diff --git a/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java b/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java
index 61b1be12828c..6e9cd628cb54 100644
--- a/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java
+++ b/processing/src/main/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcer.java
@@ -21,19 +21,11 @@
 
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
-import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
-import org.apache.druid.query.DataSource;
-import org.apache.druid.query.RestrictedDataSource;
-import org.apache.druid.segment.RestrictedSegment;
-import org.apache.druid.segment.SegmentReference;
-import org.reflections.Reflections;
 
 import javax.annotation.Nullable;
 import java.util.List;
 import java.util.Objects;
-import java.util.Set;
-import java.util.stream.Collectors;
 
 /**
  * All tables must be restricted by a policy.
@@ -50,55 +42,14 @@ public RestrictAllTablesPolicyEnforcer(
     if (allowedPolicies == null) {
       this.allowedPolicies = ImmutableList.of();
     } else {
-      Set<String> policyClazz = new Reflections("org.apache.druid.query.policy").getSubTypesOf(Policy.class)
-                                                                                .stream()
-                                                                                .map(Class::getSimpleName)
-                                                                                .collect(Collectors.toSet());
-      ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
-      List<String> unrecognizedClazz = allowedPolicies.stream()
-                                                      .filter(p -> {
-                                                        if (policyClazz.contains(p)) {
-                                                          return false;
-                                                        }
-                                                        try {
-                                                          // try load the class from its full path
-                                                          Class<?> clazz = classLoader.loadClass(p);
-                                                          return clazz.isAssignableFrom(Policy.class);
-                                                        }
-                                                        catch (ClassNotFoundException e) {
-                                                          return true;
-                                                        }
-                                                      })
-                                                      .collect(Collectors.toList());
-      Preconditions.checkArgument(
-          unrecognizedClazz.isEmpty(),
-          "Unrecognized class[%s], ensure that the class is loaded and is a subclass of Policy",
-          unrecognizedClazz
-      );
       this.allowedPolicies = ImmutableList.copyOf(allowedPolicies);
     }
   }
 
   @Override
-  public boolean validate(DataSource ds, Policy policy)
+  public boolean validate(Policy policy)
   {
-    if (ds instanceof RestrictedDataSource) {
-      return allowedPolicies.isEmpty()
-             || allowedPolicies.contains(policy.getClass().getSimpleName())
-             || allowedPolicies.contains(policy.getClass().getName());
-    }
-    return false;
-  }
-
-  @Override
-  public boolean validate(SegmentReference segment, Policy policy)
-  {
-    if (segment instanceof RestrictedSegment) {
-      return allowedPolicies.isEmpty()
-             || allowedPolicies.contains(policy.getClass().getSimpleName())
-             || allowedPolicies.contains(policy.getClass().getName());
-    }
-    return false;
+    return policy != null && (allowedPolicies.isEmpty() || allowedPolicies.contains(policy.getClass().getName()));
   }
 
   @JsonProperty
diff --git a/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java b/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java
index e2969f10d00e..454f9c9e92c1 100644
--- a/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java
+++ b/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java
@@ -20,6 +20,7 @@
 package org.apache.druid.segment;
 
 import com.google.common.base.Preconditions;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.timeline.Overshadowable;
 import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.partition.ShardSpec;
@@ -33,7 +34,7 @@
  * {@link Segment} that is also a {@link ReferenceCountingSegment}, allowing query engines that operate directly on
  * segments to track references so that dropping a {@link Segment} can be done safely to ensure there are no in-flight
  * queries.
- *
+ * <p>
  * Extensions can extend this class for populating {@link org.apache.druid.timeline.VersionedIntervalTimeline} with
  * a custom implementation through SegmentLoader.
  */
@@ -176,6 +177,14 @@ public Optional<Closeable> acquireReferences()
     return incrementReferenceAndDecrementOnceCloseable();
   }
 
+  @Override
+  public void validateOrElseThrow(PolicyEnforcer policyEnforcer)
+  {
+    if (baseObject instanceof QueryableIndexSegment) {
+      policyEnforcer.validateOrElseThrow(this, null);
+    }
+  }
+
   @Override
   public <T> T as(Class<T> clazz)
   {
diff --git a/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java b/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java
index b48e511e5b52..a8aa946ac932 100644
--- a/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java
+++ b/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java
@@ -111,9 +111,9 @@ public <T> T as(@Nonnull Class<T> clazz)
   }
 
   @Override
-  public boolean validate(PolicyEnforcer policyEnforcer)
+  public void validateOrElseThrow(PolicyEnforcer policyEnforcer)
   {
-    return policyEnforcer.validate(this, policy);
+    policyEnforcer.validateOrElseThrow(delegate, policy);
   }
 
   @Override
diff --git a/processing/src/main/java/org/apache/druid/segment/SegmentReference.java b/processing/src/main/java/org/apache/druid/segment/SegmentReference.java
index 0ece5c0ef4d3..e65952f3e552 100644
--- a/processing/src/main/java/org/apache/druid/segment/SegmentReference.java
+++ b/processing/src/main/java/org/apache/druid/segment/SegmentReference.java
@@ -33,11 +33,12 @@ public interface SegmentReference extends Segment, ReferenceCountedObject
   /**
    * Returns true if the segment complies with the policy restrictions on tables.
    * <p>
-   * This should be called right before the segment is about to be processed by the query stack.
+   * This should be called right before the segment is about to be processed by the query stack, and after
+   * {@link org.apache.druid.query.planning.ExecutionVertex#createSegmentMapFunction(PolicyEnforcer)}.
    */
-  default boolean validate(PolicyEnforcer policyEnforcer)
+  default void validateOrElseThrow(PolicyEnforcer policyEnforcer)
   {
-    return policyEnforcer.validate(this, null);
+    policyEnforcer.validateOrElseThrow(this, null);
   }
 
 }
diff --git a/processing/src/main/java/org/apache/druid/segment/WrappedSegmentReference.java b/processing/src/main/java/org/apache/druid/segment/WrappedSegmentReference.java
index ad132a9e2ec7..b9c77b07cad9 100644
--- a/processing/src/main/java/org/apache/druid/segment/WrappedSegmentReference.java
+++ b/processing/src/main/java/org/apache/druid/segment/WrappedSegmentReference.java
@@ -81,9 +81,9 @@ public <T> T as(@Nonnull Class<T> clazz)
   }
 
   @Override
-  public boolean validate(PolicyEnforcer policyEnforcer)
+  public void validateOrElseThrow(PolicyEnforcer policyEnforcer)
   {
-    return delegate.validate(policyEnforcer);
+    delegate.validateOrElseThrow(policyEnforcer);
   }
 
   @Override
diff --git a/processing/src/main/java/org/apache/druid/segment/join/HashJoinSegment.java b/processing/src/main/java/org/apache/druid/segment/join/HashJoinSegment.java
index c1ef62037f73..3f90e7dddf1b 100644
--- a/processing/src/main/java/org/apache/druid/segment/join/HashJoinSegment.java
+++ b/processing/src/main/java/org/apache/druid/segment/join/HashJoinSegment.java
@@ -138,9 +138,9 @@ public <T> T as(Class<T> clazz)
   }
 
   @Override
-  public boolean validate(PolicyEnforcer policyEnforcer)
+  public void validateOrElseThrow(PolicyEnforcer policyEnforcer)
   {
-    return baseSegment.validate(policyEnforcer);
+    baseSegment.validateOrElseThrow(policyEnforcer);
   }
 
   @Override
diff --git a/processing/src/test/java/org/apache/druid/query/DataSourceTest.java b/processing/src/test/java/org/apache/druid/query/DataSourceTest.java
index 7fcec75fca41..b87b12fc9bca 100644
--- a/processing/src/test/java/org/apache/druid/query/DataSourceTest.java
+++ b/processing/src/test/java/org/apache/druid/query/DataSourceTest.java
@@ -24,6 +24,7 @@
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
+import org.apache.druid.error.DruidException;
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.math.expr.ExprMacroTable;
 import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
@@ -33,6 +34,7 @@
 import org.apache.druid.query.policy.NoRestrictionPolicy;
 import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.policy.Policy;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.query.policy.RestrictAllTablesPolicyEnforcer;
 import org.apache.druid.query.policy.RowFilterPolicy;
 import org.apache.druid.segment.TestHelper;
@@ -130,26 +132,26 @@ public void testUnionDataSource() throws Exception
   }
 
   @Test
-  public void testWithPolicies()
+  public void testWithPolicies_onUnionDataSource()
   {
     TableDataSource table1 = TableDataSource.create("table1");
     TableDataSource table2 = TableDataSource.create("table2");
-    TableDataSource table3 = TableDataSource.create("table3");
-    UnionDataSource unionDataSource = new UnionDataSource(Lists.newArrayList(table1, table2, table3));
+    InlineDataSource inlineDataSource = InlineDataSource.fromIterable(ImmutableList.of(), RowSignature.empty());
+
+    UnionDataSource unionDataSource = new UnionDataSource(Lists.newArrayList(table1, table2, inlineDataSource));
     ImmutableMap<String, Optional<Policy>> restrictions = ImmutableMap.of(
         "table1",
         Optional.of(NoRestrictionPolicy.instance()),
         "table2",
-        Optional.of(NoRestrictionPolicy.instance()),
-        "table3",
         Optional.of(RowFilterPolicy.from(new NullFilter(
             "some-column",
             null
         )))
     );
+    PolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
 
     Assert.assertEquals(
-        unionDataSource.withPolicies(restrictions),
+        unionDataSource.withPolicies(restrictions, policyEnforcer),
         new UnionDataSource(Lists.newArrayList(
             RestrictedDataSource.create(
                 table1,
@@ -157,19 +159,47 @@ public void testWithPolicies()
             ),
             RestrictedDataSource.create(
                 table2,
-                NoRestrictionPolicy.instance()
-            ),
-            RestrictedDataSource.create(
-                table3,
                 RowFilterPolicy.from(new NullFilter(
                     "some-column",
                     null
                 ))
-            )
+            ),
+            inlineDataSource
         ))
     );
   }
 
+  @Test
+  public void testWithPolicies_onUnionDataSource_throwsOnValidation()
+  {
+    TableDataSource table1 = TableDataSource.create("table1");
+    TableDataSource table2 = TableDataSource.create("table2");
+    InlineDataSource inlineDataSource = InlineDataSource.fromIterable(ImmutableList.of(), RowSignature.empty());
+
+    UnionDataSource unionDataSource = new UnionDataSource(Lists.newArrayList(table1, table2, inlineDataSource));
+    ImmutableMap<String, Optional<Policy>> restrictions = ImmutableMap.of(
+        "table1",
+        Optional.of(NoRestrictionPolicy.instance()),
+        "table2",
+        Optional.of(RowFilterPolicy.from(new NullFilter(
+            "some-column",
+            null
+        )))
+    );
+    PolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(ImmutableList.of(NoRestrictionPolicy.class.getName()));
+
+    DruidException e = Assert.assertThrows(
+        DruidException.class,
+        () -> unionDataSource.withPolicies(restrictions, policyEnforcer)
+    );
+    Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
+    Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
+    Assert.assertEquals(
+        "Failed security validation with dataSource [table2]",
+        e.getMessage()
+    );
+  }
+
   @Test
   public void testWithPolicies_onRestrictedDataSource_fromDruidSystem()
   {
@@ -182,8 +212,9 @@ public void testWithPolicies_onRestrictedDataSource_fromDruidSystem()
         "table1",
         Optional.of(NoRestrictionPolicy.instance())
     );
+    PolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
 
-    Assert.assertEquals(restrictedDataSource, restrictedDataSource.withPolicies(noRestrictionPolicy));
+    Assert.assertEquals(restrictedDataSource, restrictedDataSource.withPolicies(noRestrictionPolicy, policyEnforcer));
   }
 
   @Test
@@ -197,8 +228,9 @@ public void testWithPolicies_onRestrictedDataSource_samePolicy()
         "table1",
         Optional.of(RowFilterPolicy.from(new NullFilter("some-column", null)))
     );
+    PolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
 
-    Assert.assertEquals(restrictedDataSource, restrictedDataSource.withPolicies(policyMap));
+    Assert.assertEquals(restrictedDataSource, restrictedDataSource.withPolicies(policyMap, policyEnforcer));
   }
 
   @Test
@@ -214,92 +246,42 @@ public void testWithPolicies_onRestrictedDataSource_alwaysThrows()
     );
     ImmutableMap<String, Optional<Policy>> noPolicyFound = ImmutableMap.of("table1", Optional.empty());
     ImmutableMap<String, Optional<Policy>> policyWasNotChecked = ImmutableMap.of();
+    PolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
 
-    ISE e = Assert.assertThrows(ISE.class, () -> restrictedDataSource.withPolicies(anotherRestrictions));
+    ISE e = Assert.assertThrows(
+        ISE.class,
+        () -> restrictedDataSource.withPolicies(anotherRestrictions, policyEnforcer)
+    );
     Assert.assertEquals(
         "Different restrictions on table [table1]: previous policy [RowFilterPolicy{rowFilter=random-column IS NULL}] and new policy [RowFilterPolicy{rowFilter=some-column IS NULL}]",
         e.getMessage()
     );
 
-    ISE e2 = Assert.assertThrows(ISE.class, () -> restrictedDataSource.withPolicies(noPolicyFound));
+    ISE e2 = Assert.assertThrows(ISE.class, () -> restrictedDataSource.withPolicies(noPolicyFound, policyEnforcer));
     Assert.assertEquals(
         "No restriction found on table [table1], but had policy [RowFilterPolicy{rowFilter=random-column IS NULL}] before.",
         e2.getMessage()
     );
-    ISE e3 = Assert.assertThrows(ISE.class, () -> restrictedDataSource.withPolicies(policyWasNotChecked));
+    ISE e3 = Assert.assertThrows(
+        ISE.class,
+        () -> restrictedDataSource.withPolicies(policyWasNotChecked, policyEnforcer)
+    );
     Assert.assertEquals("Missing policy check result for table [table1]", e3.getMessage());
   }
 
   @Test
-  public void testValidate_onInlineDataSource()
+  public void testWithPolicies_onInlineDataSource()
   {
     InlineDataSource inlineDataSource = InlineDataSource.fromIterable(ImmutableList.of(), RowSignature.empty());
-    Assert.assertTrue(inlineDataSource.validate(NoopPolicyEnforcer.instance()));
-    Assert.assertTrue(inlineDataSource.validate(new RestrictAllTablesPolicyEnforcer(null)));
-  }
-
-  @Test
-  public void testValidate_onRestrictedDataSource()
-  {
-    RestrictedDataSource restrictedDataSource = RestrictedDataSource.create(
-        TableDataSource.create("table1"),
-        RowFilterPolicy.from(new NullFilter("random-column", null))
-    );
-    Assert.assertTrue(restrictedDataSource.validate(NoopPolicyEnforcer.instance()));
-    Assert.assertTrue(restrictedDataSource.validate(new RestrictAllTablesPolicyEnforcer(null)));
-    // Fail, only NoRestrictionPolicy is allowed.
-    Assert.assertFalse(restrictedDataSource.validate(new RestrictAllTablesPolicyEnforcer(ImmutableList.of(
-        "NoRestrictionPolicy"))));
-  }
-
-  @Test
-  public void testValidate_onTableDataSource()
-  {
-    TableDataSource tableDataSource = TableDataSource.create("table1");
-    Assert.assertTrue(tableDataSource.validate(NoopPolicyEnforcer.instance()));
-    // Fail, policy must exist on table
-    Assert.assertFalse(tableDataSource.validate(new RestrictAllTablesPolicyEnforcer(null)));
-  }
-
-  @Test
-  public void testValidate_onUnionDataSource()
-  {
-    UnionDataSource unionDataSource = new UnionDataSource(Lists.newArrayList(
-        RestrictedDataSource.create(
-            TableDataSource.create("table1"),
-            RowFilterPolicy.from(new NullFilter("random-column", null))
-        ),
-        TableDataSource.create("table2")
-    ));
-    Assert.assertTrue(unionDataSource.validate(NoopPolicyEnforcer.instance()));
-    // Fail, policy must exist on table
-    Assert.assertFalse(unionDataSource.validate(new RestrictAllTablesPolicyEnforcer(null)));
-    // Fail, only NoRestrictionPolicy is allowed.
-    Assert.assertFalse(unionDataSource.validate(new RestrictAllTablesPolicyEnforcer(ImmutableList.of(
-        "NoRestrictionPolicy"))));
-
-    UnionDataSource unionDataSource2 = new UnionDataSource(Lists.newArrayList(
-        RestrictedDataSource.create(
-            TableDataSource.create("table1"),
-            RowFilterPolicy.from(new NullFilter("random-column", null))
-        ),
-        RestrictedDataSource.create(
-            TableDataSource.create("table2"),
-            RowFilterPolicy.from(new NullFilter("random-column2", null))
-        )
-    ));
-    Assert.assertTrue(unionDataSource2.validate(NoopPolicyEnforcer.instance()));
-    Assert.assertTrue(unionDataSource2.validate(new RestrictAllTablesPolicyEnforcer(null)));
-    // Fail, only NoRestrictionPolicy is allowed.
-    Assert.assertFalse(unionDataSource2.validate(new RestrictAllTablesPolicyEnforcer(ImmutableList.of(
-        "NoRestrictionPolicy"))));
+    DataSource withPolicies = inlineDataSource.withPolicies(ImmutableMap.of(), NoopPolicyEnforcer.instance());
+    Assert.assertEquals(inlineDataSource, withPolicies);
   }
 
   @Test
-  public void testValidate_onJoinDataSource()
+  public void testWithPolicies_onJoinDataSource()
   {
     JoinableFactoryWrapper joinableFactoryWrapper = new JoinableFactoryWrapper(NoopJoinableFactory.INSTANCE);
-    JoinDataSource joinDataSource1 = JoinDataSource.create(
+    JoinDataSource joinDataSource = JoinDataSource.create(
         new TableDataSource("table1"),
         new TableDataSource("table2"),
         "j.",
@@ -310,28 +292,35 @@ public void testValidate_onJoinDataSource()
         joinableFactoryWrapper,
         JoinAlgorithm.BROADCAST
     );
-    Assert.assertTrue(joinDataSource1.validate(NoopPolicyEnforcer.instance()));
-    // Fail, policy must exist on both tables
-    Assert.assertFalse(joinDataSource1.validate(new RestrictAllTablesPolicyEnforcer(null)));
+    final PolicyEnforcer policyEnforcer = NoopPolicyEnforcer.instance();
+    DataSource mapped = joinDataSource.withPolicies(ImmutableMap.of(), policyEnforcer);
+    Assert.assertEquals(joinDataSource, mapped);
 
-    JoinDataSource joinDataSource2 = JoinDataSource.create(
-        RestrictedDataSource.create(new TableDataSource("table1"), NoRestrictionPolicy.instance()),
-        new TableDataSource("table2"),
-        "j.",
-        "x == \"j.x\"",
-        JoinType.LEFT,
-        null,
-        ExprMacroTable.nil(),
-        joinableFactoryWrapper,
-        JoinAlgorithm.BROADCAST
+    // Use stricter enforcer
+    final PolicyEnforcer restrictAllTablesPolicyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    // Fail, policy must exist on both tables
+    Assert.assertThrows(
+        DruidException.class,
+        () -> joinDataSource.withPolicies(ImmutableMap.of(), restrictAllTablesPolicyEnforcer)
     );
-    Assert.assertTrue(joinDataSource2.validate(NoopPolicyEnforcer.instance()));
-    // Fail, policy must exist on table
-    Assert.assertFalse(joinDataSource2.validate(new RestrictAllTablesPolicyEnforcer(null)));
+    Assert.assertThrows(
+        DruidException.class,
+        () -> joinDataSource.withPolicies(ImmutableMap.of(
+            "table1",
+            Optional.of(NoRestrictionPolicy.instance())
+        ), restrictAllTablesPolicyEnforcer)
+    );
+
+    DataSource mapped2 = joinDataSource.withPolicies(ImmutableMap.of(
+        "table1",
+        Optional.of(NoRestrictionPolicy.instance()),
+        "table2",
+        Optional.of(NoRestrictionPolicy.instance())
+    ), restrictAllTablesPolicyEnforcer);
 
-    JoinDataSource joinDataSource3 = JoinDataSource.create(
+    JoinDataSource expected = JoinDataSource.create(
         RestrictedDataSource.create(new TableDataSource("table1"), NoRestrictionPolicy.instance()),
-        InlineDataSource.fromIterable(ImmutableList.of(), RowSignature.empty()),
+        RestrictedDataSource.create(new TableDataSource("table2"), NoRestrictionPolicy.instance()),
         "j.",
         "x == \"j.x\"",
         JoinType.LEFT,
@@ -340,8 +329,6 @@ public void testValidate_onJoinDataSource()
         joinableFactoryWrapper,
         JoinAlgorithm.BROADCAST
     );
-    Assert.assertTrue(joinDataSource3.validate(NoopPolicyEnforcer.instance()));
-    // Success, policy exist on table, and inline data source doesn't need to have policy
-    Assert.assertTrue(joinDataSource3.validate(new RestrictAllTablesPolicyEnforcer(null)));
+    Assert.assertEquals(expected, mapped2);
   }
 }
diff --git a/processing/src/test/java/org/apache/druid/query/QueryRunnerTestHelper.java b/processing/src/test/java/org/apache/druid/query/QueryRunnerTestHelper.java
index dde0928ea8ac..80cd8a55e463 100644
--- a/processing/src/test/java/org/apache/druid/query/QueryRunnerTestHelper.java
+++ b/processing/src/test/java/org/apache/druid/query/QueryRunnerTestHelper.java
@@ -54,6 +54,7 @@
 import org.apache.druid.query.dimension.DefaultDimensionSpec;
 import org.apache.druid.query.filter.SelectorDimFilter;
 import org.apache.druid.query.planning.ExecutionVertex;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.spec.MultipleIntervalSegmentSpec;
 import org.apache.druid.query.spec.QuerySegmentSpec;
 import org.apache.druid.query.spec.SpecificSegmentSpec;
@@ -558,7 +559,7 @@ public static <T, QueryType extends Query<T>> QueryRunner<T> makeQueryRunnerWith
   )
   {
     ExecutionVertex ev = ExecutionVertex.of(query);
-    final SegmentReference segmentReference = ev.createSegmentMapFunction()
+    final SegmentReference segmentReference = ev.createSegmentMapFunction(NoopPolicyEnforcer.instance())
         .apply(ReferenceCountingSegment.wrapRootGenerationSegment(adapter));
     return makeQueryRunner(factory, segmentReference, runnerName);
   }
diff --git a/processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java b/processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java
index 78bcced80488..60e78c05e96e 100644
--- a/processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java
@@ -65,14 +65,19 @@ public void test_validate() throws Exception
     TableDataSource table = TableDataSource.create("table");
     RestrictedDataSource restricted = RestrictedDataSource.create(table, policy);
 
-    Assert.assertTrue(policyEnforcer.validate(table, null));
-    Assert.assertTrue(policyEnforcer.validate(restricted, policy));
+    Assert.assertTrue(policyEnforcer.validate(null));
+    Assert.assertTrue(policyEnforcer.validate(policy));
+    policyEnforcer.validateOrElseThrow(table, null);
+    policyEnforcer.validateOrElseThrow(restricted.getBase(), restricted.getPolicy());
 
     Segment baseSegment = new TestSegmentUtils.SegmentForTesting("table", Intervals.ETERNITY, "1");
     SegmentReference segment = ReferenceCountingSegment.wrapRootGenerationSegment(baseSegment);
     RestrictedSegment restrictedSegment = new RestrictedSegment(segment, policy);
-    Assert.assertTrue(policyEnforcer.validate(segment, null));
-    Assert.assertTrue(policyEnforcer.validate(restrictedSegment, policy));
+    Assert.assertTrue(policyEnforcer.validate(null));
+    Assert.assertTrue(policyEnforcer.validate(policy));
+    policyEnforcer.validateOrElseThrow(segment, null);
+    policyEnforcer.validateOrElseThrow(restrictedSegment, policy);
+
   }
 
 }
diff --git a/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java b/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
index c58480a67873..a578582dfa64 100644
--- a/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
@@ -21,6 +21,7 @@
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.collect.ImmutableList;
+import org.apache.druid.error.DruidException;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.query.RestrictedDataSource;
 import org.apache.druid.query.TableDataSource;
@@ -39,10 +40,10 @@ public class RestrictAllTablesPolicyEnforcerTest
   @Test
   public void test_serialize() throws Exception
   {
-    RestrictAllTablesPolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    RestrictAllTablesPolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(ImmutableList.of(NoRestrictionPolicy.class.getName()));
     ObjectMapper jsonMapper = TestHelper.makeJsonMapper();
 
-    String expected = "{\"type\":\"restrictAllTables\",\"allowedPolicies\":[]}";
+    String expected = "{\"type\":\"restrictAllTables\",\"allowedPolicies\":[\"org.apache.druid.query.policy.NoRestrictionPolicy\"]}";
     Assert.assertEquals(expected, jsonMapper.writeValueAsString(policyEnforcer));
   }
 
@@ -58,20 +59,6 @@ public void test_serde_roundTrip() throws Exception
     Assert.assertEquals(policyEnforcer, deserialized);
   }
 
-  @Test
-  public void test_unrecognizedClass() throws Exception
-  {
-    Exception e = Assert.assertThrows(
-        Exception.class,
-        () -> new RestrictAllTablesPolicyEnforcer(ImmutableList.of("UnrecognizedClass"))
-    );
-    Assert.assertEquals(
-        "Unrecognized class[[UnrecognizedClass]], ensure that the class is loaded and is a subclass of Policy",
-        e.getMessage()
-    );
-
-  }
-
   @Test
   public void test_validate() throws Exception
   {
@@ -80,32 +67,58 @@ public void test_validate() throws Exception
     TableDataSource table = TableDataSource.create("table");
     RestrictedDataSource restricted = RestrictedDataSource.create(table, policy);
 
-    Assert.assertFalse(policyEnforcer.validate(table, null));
-    Assert.assertTrue(policyEnforcer.validate(restricted, policy));
+    Assert.assertFalse(policyEnforcer.validate(null));
+    Assert.assertTrue(policyEnforcer.validate(policy));
+    final DruidException e = Assert.assertThrows(
+        DruidException.class,
+        () -> policyEnforcer.validateOrElseThrow(table, null)
+    );
+    Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
+    Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
+    Assert.assertEquals(
+        "Failed security validation with dataSource [table]",
+        e.getMessage()
+    );
+    policyEnforcer.validateOrElseThrow(restricted.getBase(), restricted.getPolicy());
 
     Segment baseSegment = new SegmentForTesting("table", Intervals.ETERNITY, "1");
     SegmentReference segment = ReferenceCountingSegment.wrapRootGenerationSegment(baseSegment);
     RestrictedSegment restrictedSegment = new RestrictedSegment(segment, policy);
-    Assert.assertFalse(policyEnforcer.validate(segment, null));
-    Assert.assertTrue(policyEnforcer.validate(restrictedSegment, policy));
+    Assert.assertFalse(policyEnforcer.validate(null));
+    Assert.assertTrue(policyEnforcer.validate(policy));
+    final DruidException e2 = Assert.assertThrows(
+        DruidException.class,
+        () -> policyEnforcer.validateOrElseThrow(segment, null)
+    );
+    Assert.assertEquals(DruidException.Category.FORBIDDEN, e2.getCategory());
+    Assert.assertEquals(DruidException.Persona.OPERATOR, e2.getTargetPersona());
+    Assert.assertEquals(
+        "Failed security validation with segment [table_-146136543-09-08T08:23:32.096Z_146140482-04-24T15:36:27.903Z_1]",
+        e2.getMessage()
+    );
+    policyEnforcer.validateOrElseThrow(restrictedSegment, policy);
   }
 
   @Test
   public void test_validate_withAllowedPolicies() throws Exception
   {
     RestrictAllTablesPolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(ImmutableList.of(
-        "NoRestrictionPolicy"));
+        NoRestrictionPolicy.class.getName()));
     RowFilterPolicy policy = RowFilterPolicy.from(new NullFilter("some-col", null));
     TableDataSource table = TableDataSource.create("table");
     RestrictedDataSource restricted = RestrictedDataSource.create(table, policy);
 
-    Assert.assertFalse(policyEnforcer.validate(table, null));
-    Assert.assertFalse(policyEnforcer.validate(restricted, policy));
+    Assert.assertThrows(DruidException.class, () -> policyEnforcer.validateOrElseThrow(table, null));
+    Assert.assertThrows(
+        DruidException.class,
+        () -> policyEnforcer.validateOrElseThrow(restricted.getBase(), restricted.getPolicy())
+    );
+    policyEnforcer.validateOrElseThrow(table, NoRestrictionPolicy.instance());
 
     Segment baseSegment = new SegmentForTesting("table", Intervals.ETERNITY, "1");
     SegmentReference segment = ReferenceCountingSegment.wrapRootGenerationSegment(baseSegment);
-    RestrictedSegment restrictedSegment = new RestrictedSegment(segment, policy);
-    Assert.assertFalse(policyEnforcer.validate(segment, null));
-    Assert.assertFalse(policyEnforcer.validate(restrictedSegment, policy));
+    Assert.assertThrows(DruidException.class, () -> policyEnforcer.validateOrElseThrow(segment, null));
+    Assert.assertThrows(DruidException.class, () -> policyEnforcer.validateOrElseThrow(segment, policy));
+    policyEnforcer.validateOrElseThrow(segment, NoRestrictionPolicy.instance());
   }
 }
diff --git a/processing/src/test/java/org/apache/druid/segment/TestSegmentUtils.java b/processing/src/test/java/org/apache/druid/segment/TestSegmentUtils.java
index 51e2cfcab916..2d20be1f7f57 100644
--- a/processing/src/test/java/org/apache/druid/segment/TestSegmentUtils.java
+++ b/processing/src/test/java/org/apache/druid/segment/TestSegmentUtils.java
@@ -40,6 +40,7 @@
 import org.joda.time.Interval;
 import org.junit.Assert;
 
+import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import java.io.File;
 import java.io.IOException;
@@ -120,14 +121,14 @@ public Segment factorize(
     }
   }
 
-  public static class SegmentForTesting implements Segment
+  public static class SegmentForTesting extends QueryableIndexSegment implements Segment
   {
     private final String datasource;
     private final String version;
     private final Interval interval;
     private final Object lock = new Object();
     private volatile boolean closed = false;
-    private final QueryableIndex index = new QueryableIndex()
+    private static final QueryableIndex INDEX = new QueryableIndex()
     {
       @Override
       public Interval getDataInterval()
@@ -194,9 +195,10 @@ public ColumnHolder getColumnHolder(String columnName)
 
     public SegmentForTesting(String datasource, Interval interval, String version)
     {
+      super(INDEX, SegmentId.of(datasource, interval, version, 0));
       this.datasource = datasource;
-      this.version = version;
       this.interval = interval;
+      this.version = version;
     }
 
     public String getVersion()
@@ -229,13 +231,24 @@ public Interval getDataInterval()
     @Override
     public QueryableIndex asQueryableIndex()
     {
-      return index;
+      return INDEX;
     }
 
     @Override
     public CursorFactory asCursorFactory()
     {
-      return new QueryableIndexCursorFactory(index);
+      return new QueryableIndexCursorFactory(INDEX);
+    }
+
+    @Override
+    public <T> T as(@Nonnull Class<T> clazz)
+    {
+      if (clazz.equals(QueryableIndex.class)) {
+        return (T) asQueryableIndex();
+      } else if (clazz.equals(CursorFactory.class)) {
+        return (T) asCursorFactory();
+      }
+      return null;
     }
 
     @Override
diff --git a/server/src/main/java/org/apache/druid/client/CachingClusteredClient.java b/server/src/main/java/org/apache/druid/client/CachingClusteredClient.java
index 3a32992786ef..5594f52af7b6 100644
--- a/server/src/main/java/org/apache/druid/client/CachingClusteredClient.java
+++ b/server/src/main/java/org/apache/druid/client/CachingClusteredClient.java
@@ -39,7 +39,6 @@
 import org.apache.druid.client.cache.CacheConfig;
 import org.apache.druid.client.cache.CachePopulator;
 import org.apache.druid.client.selector.ServerSelector;
-import org.apache.druid.error.DruidException;
 import org.apache.druid.guice.annotations.Client;
 import org.apache.druid.guice.annotations.Merging;
 import org.apache.druid.guice.annotations.Smile;
@@ -74,7 +73,6 @@
 import org.apache.druid.query.context.ResponseContext;
 import org.apache.druid.query.filter.DimFilterUtils;
 import org.apache.druid.query.planning.ExecutionVertex;
-import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.server.QueryResource;
 import org.apache.druid.server.QueryScheduler;
 import org.apache.druid.server.coordination.DruidServerMetadata;
@@ -127,7 +125,6 @@ public class CachingClusteredClient implements QuerySegmentWalker
   private final BrokerParallelMergeConfig parallelMergeConfig;
   private final ForkJoinPool pool;
   private final QueryScheduler scheduler;
-  private final PolicyEnforcer policyEnforcer;
   private final ServiceEmitter emitter;
 
   @Inject
@@ -142,7 +139,6 @@ public CachingClusteredClient(
       BrokerParallelMergeConfig parallelMergeConfig,
       @Merging ForkJoinPool pool,
       QueryScheduler scheduler,
-      PolicyEnforcer policyEnforcer,
       ServiceEmitter emitter
   )
   {
@@ -156,7 +152,6 @@ public CachingClusteredClient(
     this.parallelMergeConfig = parallelMergeConfig;
     this.pool = pool;
     this.scheduler = scheduler;
-    this.policyEnforcer = policyEnforcer;
     this.emitter = emitter;
 
     if (cacheConfig.isQueryCacheable(Query.GROUP_BY) && (cacheConfig.isUseCache() || cacheConfig.isPopulateCache())) {
@@ -204,13 +199,6 @@ private <T> Sequence<T> run(
       final boolean specificSegments
   )
   {
-    Query<T> query = queryPlus.getQuery();
-    if (!query.getDataSource().validate(policyEnforcer)) {
-      throw DruidException.forPersona(DruidException.Persona.OPERATOR)
-                          .ofCategory(DruidException.Category.FORBIDDEN)
-                          .build("Failed security validation with dataSource [%s]", query.getDataSource());
-    }
-
     final ClusterQueryResult<T> result = new SpecificQueryRunnable<>(queryPlus, responseContext)
         .run(timelineConverter, specificSegments);
     initializeNumRemainingResponsesInResponseContext(queryPlus.getQuery(), responseContext, result.numQueryServers);
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SinkQuerySegmentWalker.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SinkQuerySegmentWalker.java
index 868f787619aa..37355c4b33de 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SinkQuerySegmentWalker.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SinkQuerySegmentWalker.java
@@ -29,7 +29,6 @@
 import org.apache.druid.client.cache.CacheConfig;
 import org.apache.druid.client.cache.CachePopulatorStats;
 import org.apache.druid.client.cache.ForegroundCachePopulator;
-import org.apache.druid.error.DruidException;
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.Pair;
 import org.apache.druid.java.util.common.guava.FunctionalIterable;
@@ -206,16 +205,10 @@ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final
       throw new ISE("Cannot handle subquery: %s", dataSourceFromQuery);
     }
 
-    if (!dataSourceFromQuery.validate(policyEnforcer)) {
-      throw DruidException.forPersona(DruidException.Persona.OPERATOR)
-                          .ofCategory(DruidException.Category.FORBIDDEN)
-                          .build("Failed security validation with dataSource [%s]", dataSourceFromQuery);
-    }
-
     // segmentMapFn maps each base Segment into a joined Segment if necessary.
     final Function<SegmentReference, SegmentReference> segmentMapFn = JvmUtils.safeAccumulateThreadCpuTime(
         cpuTimeAccumulator,
-        () -> ev.createSegmentMapFunction()
+        () -> ev.createSegmentMapFunction(policyEnforcer)
     );
 
     // We compute the join cache key here itself so it doesn't need to be re-computed for every segment
diff --git a/server/src/main/java/org/apache/druid/server/LocalQuerySegmentWalker.java b/server/src/main/java/org/apache/druid/server/LocalQuerySegmentWalker.java
index 7e9266c35ffe..5f149c8b3d82 100644
--- a/server/src/main/java/org/apache/druid/server/LocalQuerySegmentWalker.java
+++ b/server/src/main/java/org/apache/druid/server/LocalQuerySegmentWalker.java
@@ -34,6 +34,7 @@
 import org.apache.druid.query.QuerySegmentWalker;
 import org.apache.druid.query.SegmentDescriptor;
 import org.apache.druid.query.planning.ExecutionVertex;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.ReferenceCountingSegment;
 import org.apache.druid.segment.SegmentReference;
 import org.apache.druid.segment.SegmentWrangler;
@@ -59,6 +60,7 @@ public class LocalQuerySegmentWalker implements QuerySegmentWalker
   private final SegmentWrangler segmentWrangler;
   private final JoinableFactoryWrapper joinableFactoryWrapper;
   private final QueryScheduler scheduler;
+  private final PolicyEnforcer policyEnforcer;
   private final ServiceEmitter emitter;
 
   @Inject
@@ -67,6 +69,7 @@ public LocalQuerySegmentWalker(
       SegmentWrangler segmentWrangler,
       JoinableFactoryWrapper joinableFactoryWrapper,
       QueryScheduler scheduler,
+      PolicyEnforcer policyEnforcer,
       ServiceEmitter emitter
   )
   {
@@ -74,6 +77,7 @@ public LocalQuerySegmentWalker(
     this.segmentWrangler = segmentWrangler;
     this.joinableFactoryWrapper = joinableFactoryWrapper;
     this.scheduler = scheduler;
+    this.policyEnforcer = policyEnforcer;
     this.emitter = emitter;
   }
 
@@ -94,7 +98,7 @@ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final
 
     final AtomicLong cpuAccumulator = new AtomicLong(0L);
 
-    final Function<SegmentReference, SegmentReference> segmentMapFn = ev.createSegmentMapFunction();
+    final Function<SegmentReference, SegmentReference> segmentMapFn = ev.createSegmentMapFunction(policyEnforcer);
 
     final QueryRunnerFactory<T, Query<T>> queryRunnerFactory = conglomerate.findFactory(query);
     final QueryRunner<T> baseRunner = queryRunnerFactory.mergeRunners(
diff --git a/server/src/main/java/org/apache/druid/server/QueryLifecycle.java b/server/src/main/java/org/apache/druid/server/QueryLifecycle.java
index 5be2944b0211..5b52f3a03532 100644
--- a/server/src/main/java/org/apache/druid/server/QueryLifecycle.java
+++ b/server/src/main/java/org/apache/druid/server/QueryLifecycle.java
@@ -48,6 +48,7 @@
 import org.apache.druid.query.QueryTimeoutException;
 import org.apache.druid.query.QueryToolChest;
 import org.apache.druid.query.context.ResponseContext;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.server.QueryResource.ResourceIOReaderWriter;
 import org.apache.druid.server.log.RequestLogger;
 import org.apache.druid.server.security.Action;
@@ -98,6 +99,7 @@ public class QueryLifecycle
   private final AuthorizerMapper authorizerMapper;
   private final DefaultQueryConfig defaultQueryConfig;
   private final AuthConfig authConfig;
+  private final PolicyEnforcer policyEnforcer;
   private final long startMs;
   private final long startNs;
 
@@ -119,6 +121,7 @@ public QueryLifecycle(
       final AuthorizerMapper authorizerMapper,
       final DefaultQueryConfig defaultQueryConfig,
       final AuthConfig authConfig,
+      final PolicyEnforcer policyEnforcer,
       final long startMs,
       final long startNs
   )
@@ -131,6 +134,7 @@ public QueryLifecycle(
     this.authorizerMapper = authorizerMapper;
     this.defaultQueryConfig = defaultQueryConfig;
     this.authConfig = authConfig;
+    this.policyEnforcer = policyEnforcer;
     this.startMs = startMs;
     this.startNs = startNs;
   }
@@ -320,8 +324,11 @@ private AuthorizationResult doAuthorize(
       transition(State.AUTHORIZING, State.UNAUTHORIZED);
     } else {
       transition(State.AUTHORIZING, State.AUTHORIZED);
-      this.baseQuery = this.baseQuery.withDataSource(this.baseQuery.getDataSource()
-                                                                   .withPolicies(authorizationResult.getPolicyMap()));
+      this.baseQuery = this.baseQuery.withDataSource(baseQuery.getDataSource()
+                                                              .withPolicies(
+                                                                  authorizationResult.getPolicyMap(),
+                                                                  policyEnforcer
+                                                              ));
     }
 
     this.authenticationResult = authenticationResult;
diff --git a/server/src/main/java/org/apache/druid/server/QueryLifecycleFactory.java b/server/src/main/java/org/apache/druid/server/QueryLifecycleFactory.java
index 1dc32348bc26..73a49eca5930 100644
--- a/server/src/main/java/org/apache/druid/server/QueryLifecycleFactory.java
+++ b/server/src/main/java/org/apache/druid/server/QueryLifecycleFactory.java
@@ -27,6 +27,7 @@
 import org.apache.druid.query.GenericQueryMetricsFactory;
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
 import org.apache.druid.query.QuerySegmentWalker;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.server.log.RequestLogger;
 import org.apache.druid.server.security.AuthConfig;
 import org.apache.druid.server.security.AuthorizerMapper;
@@ -42,6 +43,7 @@ public class QueryLifecycleFactory
   private final AuthorizerMapper authorizerMapper;
   private final DefaultQueryConfig defaultQueryConfig;
   private final AuthConfig authConfig;
+  private final PolicyEnforcer policyEnforcer;
 
   @Inject
   public QueryLifecycleFactory(
@@ -51,6 +53,7 @@ public QueryLifecycleFactory(
       final ServiceEmitter emitter,
       final RequestLogger requestLogger,
       final AuthConfig authConfig,
+      final PolicyEnforcer policyEnforcer,
       final AuthorizerMapper authorizerMapper,
       final Supplier<DefaultQueryConfig> queryConfigSupplier
   )
@@ -63,6 +66,7 @@ public QueryLifecycleFactory(
     this.authorizerMapper = authorizerMapper;
     this.defaultQueryConfig = queryConfigSupplier.get();
     this.authConfig = authConfig;
+    this.policyEnforcer = policyEnforcer;
   }
 
   public QueryLifecycle factorize()
@@ -76,6 +80,7 @@ public QueryLifecycle factorize()
         authorizerMapper,
         defaultQueryConfig,
         authConfig,
+        policyEnforcer,
         System.currentTimeMillis(),
         System.nanoTime()
     );
diff --git a/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java b/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
index 75ef49508e74..953bee305e89 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
@@ -26,7 +26,6 @@
 import org.apache.druid.client.cache.Cache;
 import org.apache.druid.client.cache.CacheConfig;
 import org.apache.druid.client.cache.CachePopulator;
-import org.apache.druid.error.DruidException;
 import org.apache.druid.guice.annotations.Smile;
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.StringUtils;
@@ -194,12 +193,6 @@ public <T> QueryRunner<T> getQueryRunnerForSegments(Query<T> theQuery, Iterable<
       throw new ISE("Cannot handle subquery: %s", dataSourceFromQuery);
     }
 
-    if (!dataSourceFromQuery.validate(policyEnforcer)) {
-      throw DruidException.forPersona(DruidException.Persona.OPERATOR)
-                          .ofCategory(DruidException.Category.FORBIDDEN)
-                          .build("Failed security validation with dataSource [%s]", dataSourceFromQuery);
-    }
-
     if (maybeTimeline.isPresent()) {
       timeline = maybeTimeline.get();
     } else {
@@ -207,7 +200,7 @@ public <T> QueryRunner<T> getQueryRunnerForSegments(Query<T> theQuery, Iterable<
     }
     final Function<SegmentReference, SegmentReference> segmentMapFn = JvmUtils.safeAccumulateThreadCpuTime(
         cpuTimeAccumulator,
-        () -> ev.createSegmentMapFunction()
+        () -> ev.createSegmentMapFunction(policyEnforcer)
     );
 
     // We compute the datasource's cache key here itself so it doesn't need to be re-computed for every segment
@@ -306,7 +299,7 @@ private <T> QueryRunner<T> buildAndDecorateQueryRunner(
     MetricsEmittingQueryRunner<T> metricsEmittingQueryRunnerInner = new MetricsEmittingQueryRunner<>(
         emitter,
         toolChest,
-        new ReferenceCountingSegmentQueryRunner<>(factory, segment, segmentDescriptor, policyEnforcer),
+        new ReferenceCountingSegmentQueryRunner<>(factory, segment, segmentDescriptor),
         QueryMetrics::reportSegmentTime,
         queryMetrics -> queryMetrics.segment(segmentIdString)
     );
diff --git a/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java b/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java
index e3a6674283fc..27fb1b49cc58 100644
--- a/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java
+++ b/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java
@@ -20,7 +20,6 @@
 package org.apache.druid.client;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Ordering;
@@ -33,7 +32,6 @@
 import org.apache.druid.client.cache.MapCache;
 import org.apache.druid.client.selector.ServerSelector;
 import org.apache.druid.client.selector.TierSelectorStrategy;
-import org.apache.druid.error.DruidException;
 import org.apache.druid.guice.http.DruidHttpClientConfig;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.guava.Sequence;
@@ -42,15 +40,9 @@
 import org.apache.druid.query.Query;
 import org.apache.druid.query.QueryPlus;
 import org.apache.druid.query.QueryRunner;
-import org.apache.druid.query.RestrictedDataSource;
 import org.apache.druid.query.TableDataSource;
 import org.apache.druid.query.aggregation.CountAggregatorFactory;
 import org.apache.druid.query.context.ResponseContext;
-import org.apache.druid.query.policy.NoRestrictionPolicy;
-import org.apache.druid.query.policy.NoopPolicyEnforcer;
-import org.apache.druid.query.policy.PolicyEnforcer;
-import org.apache.druid.query.policy.RestrictAllTablesPolicyEnforcer;
-import org.apache.druid.query.timeseries.TimeseriesQuery;
 import org.apache.druid.server.QueryStackTests;
 import org.apache.druid.server.coordination.ServerType;
 import org.apache.druid.server.metrics.NoopServiceEmitter;
@@ -81,13 +73,11 @@
 public class CachingClusteredClientFunctionalityTest
 {
   private static final ObjectMapper OBJECT_MAPPER = CachingClusteredClientTestUtils.createObjectMapper();
-  private static final int DEFAULT_MERGE_LIMIT = 10;
 
   private CachingClusteredClient client;
   private VersionedIntervalTimeline<String, ServerSelector> timeline;
   private TimelineServerView serverView;
   private Cache cache;
-  private CachePopulator cachePopulator;
 
   @ClassRule
   public static QueryStackTests.Junit4ConglomerateRule conglomerateRule = new QueryStackTests.Junit4ConglomerateRule();
@@ -98,41 +88,14 @@ public void setUp()
     timeline = new VersionedIntervalTimeline<>(Ordering.natural());
     serverView = EasyMock.createNiceMock(TimelineServerView.class);
     cache = MapCache.create(100000);
-    cachePopulator = new ForegroundCachePopulator(OBJECT_MAPPER, new CachePopulatorStats(), -1);
-  }
-
-  @Test
-  public void testPolicyEnforcer()
-  {
-    client = makeClient(new RestrictAllTablesPolicyEnforcer(null));
-    final TimeseriesQuery timeseriesQuery = Druids.newTimeseriesQueryBuilder()
-                                                  .dataSource("test")
-                                                  .intervals("2015-01-02/2015-01-03")
-                                                  .granularity("day")
-                                                  .aggregators(ImmutableList.of(new CountAggregatorFactory("rows")))
-                                                  .context(ImmutableMap.of("uncoveredIntervalsLimit", 3))
-                                                  .build();
-    // query failed, expecting a restriction on dataSource
-    DruidException e = Assert.assertThrows(
-        DruidException.class,
-        () -> runQuery(client, timeseriesQuery, ResponseContext.createEmpty())
+    client = makeClient(
+        new ForegroundCachePopulator(OBJECT_MAPPER, new CachePopulatorStats(), -1)
     );
-    Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
-    Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
-    Assert.assertEquals("Failed security validation with dataSource [test]", e.getMessage());
-
-    final RestrictedDataSource restricted = RestrictedDataSource.create(
-        TableDataSource.create("test"),
-        NoRestrictionPolicy.instance()
-    );
-    final TimeseriesQuery timeseriesQueryWithRestriction = (TimeseriesQuery) timeseriesQuery.withDataSource(restricted);
-    runQuery(client, timeseriesQueryWithRestriction, ResponseContext.createEmpty());
   }
 
   @Test
   public void testUncoveredInterval()
   {
-    client = makeClient();
     addToTimeline(Intervals.of("2015-01-02/2015-01-03"), "1");
     addToTimeline(Intervals.of("2015-01-04/2015-01-05"), "1");
     addToTimeline(Intervals.of("2015-02-04/2015-02-05"), "1");
@@ -254,12 +217,16 @@ public List<QueryableDruidServer> pick(
     ));
   }
 
-  protected CachingClusteredClient makeClient()
+  protected CachingClusteredClient makeClient(final CachePopulator cachePopulator)
   {
-    return makeClient(NoopPolicyEnforcer.instance());
+    return makeClient(cachePopulator, cache, 10);
   }
 
-  protected CachingClusteredClient makeClient(PolicyEnforcer policyEnforcer)
+  protected CachingClusteredClient makeClient(
+      final CachePopulator cachePopulator,
+      final Cache cache,
+      final int mergeLimit
+  )
   {
     return new CachingClusteredClient(
         conglomerateRule.getConglomerate(),
@@ -327,7 +294,7 @@ public boolean isQueryCacheable(Query query)
           @Override
           public int getCacheBulkMergeLimit()
           {
-            return DEFAULT_MERGE_LIMIT;
+            return mergeLimit;
           }
         },
         new DruidHttpClientConfig()
@@ -362,7 +329,6 @@ public int getDefaultMaxQueryParallelism()
         },
         ForkJoinPool.commonPool(),
         QueryStackTests.DEFAULT_NOOP_SCHEDULER,
-        policyEnforcer,
         new NoopServiceEmitter()
     );
   }
diff --git a/server/src/test/java/org/apache/druid/client/CachingClusteredClientPerfTest.java b/server/src/test/java/org/apache/druid/client/CachingClusteredClientPerfTest.java
index cfcd0e31145b..d4611710e509 100644
--- a/server/src/test/java/org/apache/druid/client/CachingClusteredClientPerfTest.java
+++ b/server/src/test/java/org/apache/druid/client/CachingClusteredClientPerfTest.java
@@ -46,7 +46,6 @@
 import org.apache.druid.query.TableDataSource;
 import org.apache.druid.query.context.ResponseContext;
 import org.apache.druid.query.filter.DimFilter;
-import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.spec.MultipleIntervalSegmentSpec;
 import org.apache.druid.query.spec.MultipleSpecificSegmentSpec;
 import org.apache.druid.query.spec.QuerySegmentSpec;
@@ -140,7 +139,6 @@ public void testGetQueryRunnerForSegments_singleIntervalLargeSegments()
         Mockito.mock(BrokerParallelMergeConfig.class),
         ForkJoinPool.commonPool(),
         queryScheduler,
-        NoopPolicyEnforcer.instance(),
         new NoopServiceEmitter()
     );
 
diff --git a/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java b/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
index 4d5cc6c19080..8ea6e2e85cde 100644
--- a/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
+++ b/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
@@ -93,7 +93,6 @@
 import org.apache.druid.query.groupby.GroupByQuery;
 import org.apache.druid.query.groupby.ResultRow;
 import org.apache.druid.query.ordering.StringComparators;
-import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.search.SearchHit;
 import org.apache.druid.query.search.SearchQuery;
 import org.apache.druid.query.search.SearchQueryConfig;
@@ -2711,7 +2710,6 @@ public int getDefaultMaxQueryParallelism()
             NoQueryLaningStrategy.INSTANCE,
             new ServerConfig()
         ),
-        NoopPolicyEnforcer.instance(),
         new NoopServiceEmitter()
     );
   }
diff --git a/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java b/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
index a8a5d5393a70..86f9df62f675 100644
--- a/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
+++ b/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
@@ -94,7 +94,7 @@ public void testConfigRestrictAllTablesPolicyEnforcerWithAllowedPolicies()
   {
     Properties properties = new Properties();
     properties.setProperty("druid.policy.enforcer.type", "restrictAllTables");
-    properties.setProperty("druid.policy.enforcer.allowedPolicies", "[\"NoRestrictionPolicy\"]");
+    properties.setProperty("druid.policy.enforcer.allowedPolicies", "[\"some-policy-class\"]");
     PolicyEnforcer policyEnforcer = Guice.createInjector(
         binder -> binder.bind(Properties.class).toInstance(properties),
         new DruidGuiceExtensions(),
@@ -104,7 +104,7 @@ public void testConfigRestrictAllTablesPolicyEnforcerWithAllowedPolicies()
     ).getInstance(Key.get(PolicyEnforcer.class));
 
     Assert.assertNotNull(policyEnforcer);
-    Assert.assertEquals(new RestrictAllTablesPolicyEnforcer(ImmutableList.of("NoRestrictionPolicy")), policyEnforcer);
+    Assert.assertEquals(new RestrictAllTablesPolicyEnforcer(ImmutableList.of("some-policy-class")), policyEnforcer);
   }
 
   @Test
diff --git a/server/src/test/java/org/apache/druid/query/QueryRunnerBasedOnClusteredClientTestBase.java b/server/src/test/java/org/apache/druid/query/QueryRunnerBasedOnClusteredClientTestBase.java
index 3aa16e17f330..76a63442e3ee 100644
--- a/server/src/test/java/org/apache/druid/query/QueryRunnerBasedOnClusteredClientTestBase.java
+++ b/server/src/test/java/org/apache/druid/query/QueryRunnerBasedOnClusteredClientTestBase.java
@@ -43,7 +43,6 @@
 import org.apache.druid.query.aggregation.CountAggregatorFactory;
 import org.apache.druid.query.context.ConcurrentResponseContext;
 import org.apache.druid.query.context.ResponseContext;
-import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.timeseries.TimeseriesResultValue;
 import org.apache.druid.query.topn.TopNQueryConfig;
 import org.apache.druid.segment.QueryableIndex;
@@ -133,7 +132,6 @@ public void setupTestBase()
         QueryStackTests.getParallelMergeConfig(USE_PARALLEL_MERGE_POOL_CONFIGURED),
         ForkJoinPool.commonPool(),
         QueryStackTests.DEFAULT_NOOP_SCHEDULER,
-        NoopPolicyEnforcer.instance(),
         new NoopServiceEmitter()
     );
     servers = new ArrayList<>();
diff --git a/server/src/test/java/org/apache/druid/segment/metadata/SegmentMetadataCacheTestBase.java b/server/src/test/java/org/apache/druid/segment/metadata/SegmentMetadataCacheTestBase.java
index 60195a7a3efe..e8380b2f3031 100644
--- a/server/src/test/java/org/apache/druid/segment/metadata/SegmentMetadataCacheTestBase.java
+++ b/server/src/test/java/org/apache/druid/segment/metadata/SegmentMetadataCacheTestBase.java
@@ -37,6 +37,7 @@
 import org.apache.druid.query.aggregation.DoubleSumAggregatorFactory;
 import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
 import org.apache.druid.query.aggregation.hyperloglog.HyperUniquesAggregatorFactory;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.segment.IndexBuilder;
 import org.apache.druid.segment.QueryableIndex;
 import org.apache.druid.segment.incremental.IncrementalIndexSchema;
@@ -293,6 +294,7 @@ public QueryLifecycleFactory getQueryLifecycleFactory(QuerySegmentWalker walker)
         new NoopServiceEmitter(),
         new TestRequestLogger(),
         new AuthConfig(),
+        NoopPolicyEnforcer.instance(),
         AuthTestUtils.TEST_AUTHORIZER_MAPPER,
         Suppliers.ofInstance(new DefaultQueryConfig(ImmutableMap.of()))
     );
diff --git a/server/src/test/java/org/apache/druid/server/QueryLifecycleTest.java b/server/src/test/java/org/apache/druid/server/QueryLifecycleTest.java
index c317bc291702..d202a60078c5 100644
--- a/server/src/test/java/org/apache/druid/server/QueryLifecycleTest.java
+++ b/server/src/test/java/org/apache/druid/server/QueryLifecycleTest.java
@@ -19,10 +19,18 @@
 
 package org.apache.druid.server;
 
+import com.google.common.base.Supplier;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
+import com.google.inject.Guice;
+import com.google.inject.Inject;
+import com.google.inject.Injector;
+import com.google.inject.Scopes;
+import com.google.inject.testing.fieldbinder.Bind;
+import com.google.inject.testing.fieldbinder.BoundFieldModule;
 import org.apache.druid.error.DruidException;
+import org.apache.druid.guice.LazySingleton;
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.guava.Sequences;
@@ -45,7 +53,10 @@
 import org.apache.druid.query.filter.NullFilter;
 import org.apache.druid.query.metadata.metadata.SegmentMetadataQuery;
 import org.apache.druid.query.policy.NoRestrictionPolicy;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.policy.Policy;
+import org.apache.druid.query.policy.PolicyEnforcer;
+import org.apache.druid.query.policy.RestrictAllTablesPolicyEnforcer;
 import org.apache.druid.query.policy.RowFilterPolicy;
 import org.apache.druid.query.timeseries.TimeseriesQuery;
 import org.apache.druid.server.log.RequestLogger;
@@ -72,6 +83,7 @@
 import java.util.Map;
 import java.util.Optional;
 
+@LazySingleton
 public class QueryLifecycleTest
 {
   private static final String DATASOURCE = "some_datasource";
@@ -85,19 +97,40 @@ public class QueryLifecycleTest
                                               .intervals(ImmutableList.of(Intervals.ETERNITY))
                                               .aggregators(new CountAggregatorFactory("chocula"))
                                               .build();
+  QueryToolChest toolChest;
+  @Bind
   QueryRunnerFactoryConglomerate conglomerate;
+
+  QueryRunner runner;
+  @Bind
   QuerySegmentWalker texasRanger;
+  @Bind
   GenericQueryMetricsFactory metricsFactory;
+  @Bind
   ServiceEmitter emitter;
+  @Bind
   RequestLogger requestLogger;
+
+  Authorizer authorizer;
+  @Bind
   AuthorizerMapper authzMapper;
+
   DefaultQueryConfig queryConfig;
+  @Bind(lazy = true)
+  Supplier<DefaultQueryConfig> queryConfigSupplier;
+
+  @Bind(lazy = true)
+  AuthConfig authConfig;
+  @Bind(lazy = true)
+  PolicyEnforcer policyEnforcer;
 
-  QueryToolChest toolChest;
-  QueryRunner runner;
   QueryMetrics metrics;
   AuthenticationResult authenticationResult;
-  Authorizer authorizer;
+
+  @Inject
+  QueryLifecycleFactory queryLifecycleFactory;
+
+  Injector injector;
 
   @Rule
   public ExpectedException expectedException = ExpectedException.none();
@@ -113,29 +146,25 @@ public void setup()
     authorizer = EasyMock.createMock(Authorizer.class);
     authzMapper = new AuthorizerMapper(ImmutableMap.of(AUTHORIZER, authorizer));
     queryConfig = EasyMock.createMock(DefaultQueryConfig.class);
+    queryConfigSupplier = () -> queryConfig;
 
     toolChest = EasyMock.createMock(QueryToolChest.class);
     runner = EasyMock.createMock(QueryRunner.class);
     metrics = EasyMock.createNiceMock(QueryMetrics.class);
     authenticationResult = EasyMock.createMock(AuthenticationResult.class);
+    authConfig = new AuthConfig();
+    policyEnforcer = NoopPolicyEnforcer.instance();
+
+    injector = Guice.createInjector(
+        BoundFieldModule.of(this),
+        binder -> binder.bindScope(LazySingleton.class, Scopes.SINGLETON)
+    );
   }
 
-  private QueryLifecycle createLifecycle(AuthConfig authConfig)
+  private QueryLifecycle createLifecycle()
   {
-    long nanos = System.nanoTime();
-    long millis = System.currentTimeMillis();
-    return new QueryLifecycle(
-        conglomerate,
-        texasRanger,
-        metricsFactory,
-        emitter,
-        requestLogger,
-        authzMapper,
-        queryConfig,
-        authConfig,
-        millis,
-        nanos
-    );
+    injector.injectMembers(this);
+    return queryLifecycleFactory.factorize();
   }
 
   @After
@@ -171,7 +200,7 @@ public void testRunSimple_preauthorizedAsSuperuser()
 
     replayAll();
 
-    QueryLifecycle lifecycle = createLifecycle(new AuthConfig());
+    QueryLifecycle lifecycle = createLifecycle();
     lifecycle.runSimple(query, authenticationResult, AuthorizationResult.ALLOW_NO_RESTRICTION);
   }
 
@@ -189,7 +218,7 @@ public void testRunSimpleUnauthorized()
     EasyMock.expect(toolChest.makeMetrics(EasyMock.anyObject())).andReturn(metrics).anyTimes();
     replayAll();
 
-    QueryLifecycle lifecycle = createLifecycle(new AuthConfig());
+    QueryLifecycle lifecycle = createLifecycle();
     lifecycle.runSimple(query, authenticationResult, AuthorizationResult.DENY);
   }
 
@@ -223,10 +252,10 @@ public void testRunSimple_withPolicyRestriction()
     EasyMock.expect(runner.run(EasyMock.anyObject(), EasyMock.anyObject())).andReturn(Sequences.empty()).once();
     replayAll();
 
-    AuthConfig authConfig = AuthConfig.newBuilder()
-                                      .setAuthorizeQueryContextParams(true)
-                                      .build();
-    QueryLifecycle lifecycle = createLifecycle(authConfig);
+    authConfig = AuthConfig.newBuilder()
+                           .setAuthorizeQueryContextParams(true)
+                           .build();
+    QueryLifecycle lifecycle = createLifecycle();
     lifecycle.runSimple(query, authenticationResult, authorizationResult);
   }
 
@@ -255,7 +284,7 @@ public void testRunSimple_withPolicyRestriction_segmentMetadataQueryRunAsInterna
     EasyMock.expect(runner.run(EasyMock.anyObject(), EasyMock.anyObject())).andReturn(Sequences.empty()).once();
     replayAll();
 
-    QueryLifecycle lifecycle = createLifecycle(new AuthConfig());
+    QueryLifecycle lifecycle = createLifecycle();
     lifecycle.runSimple(query, authenticationResult, authorizationResult);
   }
 
@@ -279,14 +308,17 @@ public void testRunSimple_withPolicyRestriction_segmentMetadataQueryRunAsExterna
     EasyMock.expect(toolChest.makeMetrics(EasyMock.anyObject())).andReturn(metrics).once();
     replayAll();
 
-    QueryLifecycle lifecycle = createLifecycle(new AuthConfig());
+    QueryLifecycle lifecycle = createLifecycle();
     DruidException e = Assert.assertThrows(
         DruidException.class,
         () -> lifecycle.runSimple(query, authenticationResult, authorizationResult)
     );
     Assert.assertEquals(DruidException.Persona.USER, e.getTargetPersona());
     Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
-    Assert.assertEquals("You do not have permission to run a segmentMetadata query on table[some_datasource].", e.getMessage());
+    Assert.assertEquals(
+        "You do not have permission to run a segmentMetadata query on table[some_datasource].",
+        e.getMessage()
+    );
   }
 
   @Test
@@ -305,7 +337,7 @@ public void testRunSimple_withoutPolicy()
     EasyMock.expect(toolChest.makeMetrics(EasyMock.anyObject())).andReturn(metrics).anyTimes();
     replayAll();
 
-    QueryLifecycle lifecycle = createLifecycle(AuthConfig.newBuilder().build());
+    QueryLifecycle lifecycle = createLifecycle();
     lifecycle.runSimple(query, authenticationResult, authorizationResult);
   }
 
@@ -345,7 +377,7 @@ public void testRunSimple_foundDifferentPolicyRestrictions()
     EasyMock.expect(runner.run(EasyMock.anyObject(), EasyMock.anyObject())).andReturn(Sequences.empty()).anyTimes();
     replayAll();
 
-    QueryLifecycle lifecycle = createLifecycle(new AuthConfig());
+    QueryLifecycle lifecycle = createLifecycle();
     lifecycle.runSimple(query, authenticationResult, authorizationResult);
   }
 
@@ -387,7 +419,7 @@ public void testRunSimple_queryWithRestrictedDataSource_policyRestrictionMightHa
     EasyMock.expect(runner.run(EasyMock.anyObject(), EasyMock.anyObject())).andReturn(Sequences.empty()).anyTimes();
     replayAll();
 
-    QueryLifecycle lifecycle = createLifecycle(new AuthConfig());
+    QueryLifecycle lifecycle = createLifecycle();
     lifecycle.runSimple(query, authenticationResult, authorizationResult);
   }
 
@@ -422,12 +454,52 @@ public void testAuthorized_withPolicyRestriction()
     EasyMock.expect(runner.run(EasyMock.anyObject(), EasyMock.anyObject())).andReturn(Sequences.empty()).anyTimes();
     replayAll();
 
-    QueryLifecycle lifecycle = createLifecycle(new AuthConfig());
+    QueryLifecycle lifecycle = createLifecycle();
     lifecycle.initialize(query);
     Assert.assertTrue(lifecycle.authorize(authenticationResult).allowBasicAccess());
     lifecycle.execute();
   }
 
+  @Test
+  public void testAuthorized_withPolicyRestriction_failedSecurityValidation()
+  {
+    // Test the path broker receives a native json query from external client, should add restriction on data source
+    Policy rowFilterPolicy = RowFilterPolicy.from(new NullFilter("some-column", null));
+    Access access = Access.allowWithRestriction(rowFilterPolicy);
+
+    DataSource expectedDataSource = RestrictedDataSource.create(TableDataSource.create(DATASOURCE), rowFilterPolicy);
+
+    final TimeseriesQuery query = Druids.newTimeseriesQueryBuilder()
+                                        .dataSource(DATASOURCE)
+                                        .intervals(ImmutableList.of(Intervals.ETERNITY))
+                                        .aggregators(new CountAggregatorFactory("chocula"))
+                                        .build();
+    EasyMock.expect(queryConfig.getContext()).andReturn(ImmutableMap.of()).anyTimes();
+    EasyMock.expect(authenticationResult.getIdentity()).andReturn(IDENTITY).anyTimes();
+    EasyMock.expect(authenticationResult.getAuthorizerName()).andReturn(AUTHORIZER).anyTimes();
+    EasyMock.expect(authorizer.authorize(authenticationResult, RESOURCE, Action.READ))
+            .andReturn(access).anyTimes();
+    EasyMock.expect(conglomerate.getToolChest(EasyMock.anyObject()))
+            .andReturn(toolChest).anyTimes();
+    // We're expecting the data source in the query to be transformed to a RestrictedDataSource, with policy.
+    // Any other DataSource would throw AssertionError.
+    EasyMock.expect(texasRanger.getQueryRunnerForIntervals(
+                queryMatchDataSource(expectedDataSource),
+                EasyMock.anyObject()
+            ))
+            .andReturn(runner).anyTimes();
+    EasyMock.expect(runner.run(EasyMock.anyObject(), EasyMock.anyObject())).andReturn(Sequences.empty()).anyTimes();
+    replayAll();
+
+    policyEnforcer = new RestrictAllTablesPolicyEnforcer(ImmutableList.of(NoRestrictionPolicy.class.getName()));
+    QueryLifecycle lifecycle = createLifecycle();
+    lifecycle.initialize(query);
+    DruidException e = Assert.assertThrows(DruidException.class, () -> lifecycle.authorize(authenticationResult));
+    Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
+    Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
+    Assert.assertEquals("Failed security validation with dataSource [some_datasource]", e.getMessage());
+  }
+
   @Test
   public void testAuthorized_queryWithRestrictedDataSource_runWithSuperUserPermission()
   {
@@ -459,10 +531,8 @@ public void testAuthorized_queryWithRestrictedDataSource_runWithSuperUserPermiss
     EasyMock.expect(runner.run(EasyMock.anyObject(), EasyMock.anyObject())).andReturn(Sequences.empty()).anyTimes();
     replayAll();
 
-    AuthConfig authConfig = AuthConfig.newBuilder()
-                                      .setAuthorizeQueryContextParams(true)
-                                      .build();
-    QueryLifecycle lifecycle = createLifecycle(authConfig);
+    authConfig = AuthConfig.newBuilder().setAuthorizeQueryContextParams(true).build();
+    QueryLifecycle lifecycle = createLifecycle();
     lifecycle.initialize(query);
     Assert.assertTrue(lifecycle.authorize(authenticationResult).allowBasicAccess());
     lifecycle.execute();
@@ -507,10 +577,8 @@ public void testAuthorizeQueryContext_authorized()
                                         .context(userContext)
                                         .build();
 
-    AuthConfig authConfig = AuthConfig.newBuilder()
-                                      .setAuthorizeQueryContextParams(true)
-                                      .build();
-    QueryLifecycle lifecycle = createLifecycle(authConfig);
+    authConfig = AuthConfig.newBuilder().setAuthorizeQueryContextParams(true).build();
+    QueryLifecycle lifecycle = createLifecycle();
     lifecycle.initialize(query);
 
     final Map<String, Object> revisedContext = new HashMap<>(lifecycle.getQuery().getContext());
@@ -523,7 +591,7 @@ public void testAuthorizeQueryContext_authorized()
 
     Assert.assertTrue(lifecycle.authorize(mockRequest()).allowAccessWithNoRestriction());
 
-    lifecycle = createLifecycle(authConfig);
+    lifecycle = createLifecycle();
     lifecycle.initialize(query);
     Assert.assertTrue(lifecycle.authorize(authenticationResult).allowAccessWithNoRestriction());
   }
@@ -562,14 +630,12 @@ public void testAuthorizeQueryContext_notAuthorized()
                                         .context(ImmutableMap.of("foo", "bar"))
                                         .build();
 
-    AuthConfig authConfig = AuthConfig.newBuilder()
-                                      .setAuthorizeQueryContextParams(true)
-                                      .build();
-    QueryLifecycle lifecycle = createLifecycle(authConfig);
+    authConfig = AuthConfig.newBuilder().setAuthorizeQueryContextParams(true).build();
+    QueryLifecycle lifecycle = createLifecycle();
     lifecycle.initialize(query);
     Assert.assertFalse(lifecycle.authorize(mockRequest()).allowBasicAccess());
 
-    lifecycle = createLifecycle(authConfig);
+    lifecycle = createLifecycle();
     lifecycle.initialize(query);
     Assert.assertFalse(lifecycle.authorize(authenticationResult).allowBasicAccess());
   }
@@ -598,11 +664,11 @@ public void testAuthorizeQueryContext_unsecuredKeys()
                                         .context(userContext)
                                         .build();
 
-    AuthConfig authConfig = AuthConfig.newBuilder()
-                                      .setAuthorizeQueryContextParams(true)
-                                      .setUnsecuredContextKeys(ImmutableSet.of("foo", "baz"))
-                                      .build();
-    QueryLifecycle lifecycle = createLifecycle(authConfig);
+    authConfig = AuthConfig.newBuilder()
+                           .setAuthorizeQueryContextParams(true)
+                           .setUnsecuredContextKeys(ImmutableSet.of("foo", "baz"))
+                           .build();
+    QueryLifecycle lifecycle = createLifecycle();
     lifecycle.initialize(query);
 
     final Map<String, Object> revisedContext = new HashMap<>(lifecycle.getQuery().getContext());
@@ -615,7 +681,7 @@ public void testAuthorizeQueryContext_unsecuredKeys()
 
     Assert.assertTrue(lifecycle.authorize(mockRequest()).allowAccessWithNoRestriction());
 
-    lifecycle = createLifecycle(authConfig);
+    lifecycle = createLifecycle();
     lifecycle.initialize(query);
     Assert.assertTrue(lifecycle.authorize(authenticationResult).allowAccessWithNoRestriction());
   }
@@ -648,12 +714,12 @@ public void testAuthorizeQueryContext_securedKeys()
                                         .context(userContext)
                                         .build();
 
-    AuthConfig authConfig = AuthConfig.newBuilder()
-                                      .setAuthorizeQueryContextParams(true)
-                                      // We have secured keys, just not what the user gave.
-                                      .setSecuredContextKeys(ImmutableSet.of("foo2", "baz2"))
-                                      .build();
-    QueryLifecycle lifecycle = createLifecycle(authConfig);
+    authConfig = AuthConfig.newBuilder()
+                           .setAuthorizeQueryContextParams(true)
+                           // We have secured keys, just not what the user gave.
+                           .setSecuredContextKeys(ImmutableSet.of("foo2", "baz2"))
+                           .build();
+    QueryLifecycle lifecycle = createLifecycle();
     lifecycle.initialize(query);
 
     final Map<String, Object> revisedContext = new HashMap<>(lifecycle.getQuery().getContext());
@@ -666,7 +732,7 @@ public void testAuthorizeQueryContext_securedKeys()
 
     Assert.assertTrue(lifecycle.authorize(mockRequest()).allowBasicAccess());
 
-    lifecycle = createLifecycle(authConfig);
+    lifecycle = createLifecycle();
     lifecycle.initialize(query);
     Assert.assertTrue(lifecycle.authorize(authenticationResult).allowBasicAccess());
   }
@@ -706,16 +772,16 @@ public void testAuthorizeQueryContext_securedKeysNotAuthorized()
                                         .context(userContext)
                                         .build();
 
-    AuthConfig authConfig = AuthConfig.newBuilder()
-                                      .setAuthorizeQueryContextParams(true)
-                                      // We have secured keys. User used one of them.
-                                      .setSecuredContextKeys(ImmutableSet.of("foo", "baz2"))
-                                      .build();
-    QueryLifecycle lifecycle = createLifecycle(authConfig);
+    authConfig = AuthConfig.newBuilder()
+                           .setAuthorizeQueryContextParams(true)
+                           // We have secured keys. User used one of them.
+                           .setSecuredContextKeys(ImmutableSet.of("foo", "baz2"))
+                           .build();
+    QueryLifecycle lifecycle = createLifecycle();
     lifecycle.initialize(query);
     Assert.assertFalse(lifecycle.authorize(mockRequest()).allowBasicAccess());
 
-    lifecycle = createLifecycle(authConfig);
+    lifecycle = createLifecycle();
     lifecycle.initialize(query);
     Assert.assertFalse(lifecycle.authorize(authenticationResult).allowBasicAccess());
   }
@@ -761,10 +827,10 @@ public void testAuthorizeLegacyQueryContext_authorized()
         "qux"
     ));
 
-    AuthConfig authConfig = AuthConfig.newBuilder()
-                                      .setAuthorizeQueryContextParams(true)
-                                      .build();
-    QueryLifecycle lifecycle = createLifecycle(authConfig);
+    authConfig = AuthConfig.newBuilder()
+                           .setAuthorizeQueryContextParams(true)
+                           .build();
+    QueryLifecycle lifecycle = createLifecycle();
     lifecycle.initialize(query);
 
     final Map<String, Object> revisedContext = lifecycle.getQuery().getContext();
@@ -775,7 +841,7 @@ public void testAuthorizeLegacyQueryContext_authorized()
 
     Assert.assertTrue(lifecycle.authorize(mockRequest()).allowBasicAccess());
 
-    lifecycle = createLifecycle(authConfig);
+    lifecycle = createLifecycle();
     lifecycle.initialize(query);
     Assert.assertTrue(lifecycle.authorize(mockRequest()).allowBasicAccess());
   }
diff --git a/server/src/test/java/org/apache/druid/server/QueryResourceTest.java b/server/src/test/java/org/apache/druid/server/QueryResourceTest.java
index 6f87127b0968..684092904848 100644
--- a/server/src/test/java/org/apache/druid/server/QueryResourceTest.java
+++ b/server/src/test/java/org/apache/druid/server/QueryResourceTest.java
@@ -65,6 +65,7 @@
 import org.apache.druid.query.SegmentDescriptor;
 import org.apache.druid.query.TruncatedResponseContextException;
 import org.apache.druid.query.filter.NullFilter;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.policy.RowFilterPolicy;
 import org.apache.druid.query.timeboundary.TimeBoundaryResultValue;
 import org.apache.druid.server.initialization.ServerConfig;
@@ -247,6 +248,7 @@ private QueryResource createQueryResource(ResponseContextConfig responseContextC
             new NoopServiceEmitter(),
             testRequestLogger,
             new AuthConfig(),
+            NoopPolicyEnforcer.instance(),
             AuthTestUtils.TEST_AUTHORIZER_MAPPER,
             Suppliers.ofInstance(new DefaultQueryConfig(ImmutableMap.of()))
         ),
@@ -282,6 +284,7 @@ public void testGoodQueryWithQueryConfigOverrideDefault() throws IOException
             new NoopServiceEmitter(),
             testRequestLogger,
             new AuthConfig(),
+            NoopPolicyEnforcer.instance(),
             AuthTestUtils.TEST_AUTHORIZER_MAPPER,
             Suppliers.ofInstance(overrideConfig)
         ),
@@ -356,6 +359,7 @@ public <T> QueryRunner<T> getQueryRunnerForSegments(
             new NoopServiceEmitter(),
             testRequestLogger,
             new AuthConfig(),
+            NoopPolicyEnforcer.instance(),
             AuthTestUtils.TEST_AUTHORIZER_MAPPER,
             Suppliers.ofInstance(overrideConfig)
         ),
@@ -448,6 +452,7 @@ public <T> QueryRunner<T> getQueryRunnerForSegments(
             new NoopServiceEmitter(),
             testRequestLogger,
             new AuthConfig(),
+            NoopPolicyEnforcer.instance(),
             AuthTestUtils.TEST_AUTHORIZER_MAPPER,
             Suppliers.ofInstance(new DefaultQueryConfig(ImmutableMap.of()))
         ),
@@ -493,6 +498,7 @@ public void testSuccessResponseWithTrailerHeader() throws IOException
             new NoopServiceEmitter(),
             testRequestLogger,
             new AuthConfig(),
+            NoopPolicyEnforcer.instance(),
             AuthTestUtils.TEST_AUTHORIZER_MAPPER,
             Suppliers.ofInstance(new DefaultQueryConfig(ImmutableMap.of()))
         ),
@@ -553,7 +559,7 @@ public <T> QueryRunner<T> getQueryRunnerForSegments(
 
     queryResource = new QueryResource(
 
-        new QueryLifecycleFactory(null, null, null, null, null, null, null, Suppliers.ofInstance(overrideConfig))
+        new QueryLifecycleFactory(null, null, null, null, null, null, NoopPolicyEnforcer.instance(), null, Suppliers.ofInstance(overrideConfig))
         {
           @Override
           public QueryLifecycle factorize()
@@ -567,6 +573,7 @@ public QueryLifecycle factorize()
                 AuthTestUtils.TEST_AUTHORIZER_MAPPER,
                 overrideConfig,
                 new AuthConfig(),
+                NoopPolicyEnforcer.instance(),
                 System.currentTimeMillis(),
                 System.nanoTime()
             )
@@ -618,6 +625,7 @@ public void testGoodQueryWithQueryConfigDoesNotOverrideQueryContext() throws IOE
             new NoopServiceEmitter(),
             testRequestLogger,
             new AuthConfig(),
+            NoopPolicyEnforcer.instance(),
             AuthTestUtils.TEST_AUTHORIZER_MAPPER,
             Suppliers.ofInstance(overrideConfig)
         ),
@@ -855,6 +863,7 @@ public Access authorize(AuthenticationResult authenticationResult, Resource reso
             new NoopServiceEmitter(),
             testRequestLogger,
             new AuthConfig(),
+            NoopPolicyEnforcer.instance(),
             authMapper,
             Suppliers.ofInstance(new DefaultQueryConfig(ImmutableMap.of()))
         ),
@@ -930,6 +939,7 @@ public <T> QueryRunner<T> getQueryRunnerForSegments(Query<T> query, Iterable<Seg
             new NoopServiceEmitter(),
             testRequestLogger,
             new AuthConfig(),
+            NoopPolicyEnforcer.instance(),
             AuthTestUtils.TEST_AUTHORIZER_MAPPER,
             Suppliers.ofInstance(new DefaultQueryConfig(ImmutableMap.of()))
         ),
@@ -1026,6 +1036,7 @@ public Access authorize(AuthenticationResult authenticationResult, Resource reso
             new NoopServiceEmitter(),
             testRequestLogger,
             new AuthConfig(),
+            NoopPolicyEnforcer.instance(),
             authMapper,
             Suppliers.ofInstance(new DefaultQueryConfig(ImmutableMap.of()))
         ),
@@ -1133,6 +1144,7 @@ public Access authorize(AuthenticationResult authenticationResult, Resource reso
             new NoopServiceEmitter(),
             testRequestLogger,
             new AuthConfig(),
+            NoopPolicyEnforcer.instance(),
             authMapper,
             Suppliers.ofInstance(new DefaultQueryConfig(ImmutableMap.of()))
         ),
@@ -1487,6 +1499,7 @@ public <T> QueryRunner<T> getQueryRunnerForSegments(Query<T> query, Iterable<Seg
             new NoopServiceEmitter(),
             testRequestLogger,
             new AuthConfig(),
+            NoopPolicyEnforcer.instance(),
             AuthTestUtils.TEST_AUTHORIZER_MAPPER,
             Suppliers.ofInstance(new DefaultQueryConfig(ImmutableMap.of()))
         ),
diff --git a/server/src/test/java/org/apache/druid/server/QueryStackTests.java b/server/src/test/java/org/apache/druid/server/QueryStackTests.java
index 9184f96b1733..a3d14fa2c2dd 100644
--- a/server/src/test/java/org/apache/druid/server/QueryStackTests.java
+++ b/server/src/test/java/org/apache/druid/server/QueryStackTests.java
@@ -62,6 +62,7 @@
 import org.apache.druid.query.metadata.metadata.SegmentMetadataQuery;
 import org.apache.druid.query.operator.WindowOperatorQuery;
 import org.apache.druid.query.operator.WindowOperatorQueryQueryRunnerFactory;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.scan.ScanQuery;
 import org.apache.druid.query.scan.ScanQueryConfig;
 import org.apache.druid.query.scan.ScanQueryEngine;
@@ -213,6 +214,7 @@ public static LocalQuerySegmentWalker createLocalQuerySegmentWalker(
         segmentWrangler,
         joinableFactoryWrapper,
         scheduler,
+        NoopPolicyEnforcer.instance(),
         emitter
     );
   }
diff --git a/server/src/test/java/org/apache/druid/server/TestClusterQuerySegmentWalker.java b/server/src/test/java/org/apache/druid/server/TestClusterQuerySegmentWalker.java
index d29c2837d35c..71480d7c2be7 100644
--- a/server/src/test/java/org/apache/druid/server/TestClusterQuerySegmentWalker.java
+++ b/server/src/test/java/org/apache/druid/server/TestClusterQuerySegmentWalker.java
@@ -156,7 +156,7 @@ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final
       throw new ISE("Cannot handle subquery: %s", dataSourceFromQuery);
     }
 
-    final Function<SegmentReference, SegmentReference> segmentMapFn = ev.createSegmentMapFunction();
+    final Function<SegmentReference, SegmentReference> segmentMapFn = ev.createSegmentMapFunction(NoopPolicyEnforcer.instance());
 
     final QueryRunner<T> baseRunner = new FinalizeResultsQueryRunner<>(
         toolChest.postMergeQueryDecoration(
@@ -241,8 +241,7 @@ private <T> QueryRunner<T> makeTableRunner(
                                 new ReferenceCountingSegmentQueryRunner<>(
                                     factory,
                                     segmentMapFn.apply(segment.getSegment()),
-                                    segment.getDescriptor(),
-                                    NoopPolicyEnforcer.instance()
+                                    segment.getDescriptor()
                                 ),
                                 new SpecificSegmentSpec(segment.getDescriptor())
                             )
diff --git a/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java b/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
index ee173bd13c7f..8364ff40835c 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
@@ -608,7 +608,6 @@ public void testGetQueryRunnerForSegments_restricted() throws Exception
         SearchQuery.class,
         factory
     ));
-    policyEnforcer = new RestrictAllTablesPolicyEnforcer(ImmutableList.of("NoRestrictionPolicy"));
     serverManager = Guice.createInjector(BoundFieldModule.of(this)).getInstance(ServerManager.class);
     Interval interval = Intervals.of("P1d/2011-04-01");
     SearchQuery query = searchQuery("test", interval, Granularities.ALL);
@@ -617,14 +616,27 @@ public void testGetQueryRunnerForSegments_restricted() throws Exception
         NoRestrictionPolicy.instance()
     ), interval, Granularities.ALL);
 
+    serverManager.getQueryRunnerForIntervals(query, ImmutableList.of(interval)).run(QueryPlus.wrap(query)).toList();
+    // switch to a policy enforcer that restricts all tables
+    policyEnforcer = new RestrictAllTablesPolicyEnforcer(ImmutableList.of(NoRestrictionPolicy.class.getName()));
+    serverManager = Guice.createInjector(BoundFieldModule.of(this)).getInstance(ServerManager.class);
+    // fail on query
     DruidException e = Assert.assertThrows(
         DruidException.class,
         () -> serverManager.getQueryRunnerForIntervals(query, ImmutableList.of(interval))
+                           .run(QueryPlus.wrap(query))
+                           .toList()
     );
     Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
     Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
-    Assert.assertEquals("Failed security validation with dataSource [test]", e.getMessage());
-    Assert.assertNotNull(serverManager.getQueryRunnerForIntervals(queryOnRestricted, ImmutableList.of(interval)));
+    Assert.assertEquals(
+        "Failed security validation with segment [test_2011-03-31T00:00:00.000Z_2011-04-01T00:00:00.000Z_1]",
+        e.getMessage()
+    );
+    // succeed on queryOnRestricted
+    serverManager.getQueryRunnerForIntervals(queryOnRestricted, ImmutableList.of(interval))
+                 .run(QueryPlus.wrap(queryOnRestricted))
+                 .toList();
   }
 
   private void waitForTestVerificationAndCleanup(Future future)
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/PlannerFactory.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/PlannerFactory.java
index 3e69d275471f..84587d639062 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/PlannerFactory.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/PlannerFactory.java
@@ -40,6 +40,7 @@
 import org.apache.druid.guice.annotations.Json;
 import org.apache.druid.math.expr.ExprMacroTable;
 import org.apache.druid.query.QueryContexts;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.join.JoinableFactoryWrapper;
 import org.apache.druid.server.security.AuthConfig;
 import org.apache.druid.server.security.AuthorizationResult;
@@ -81,6 +82,7 @@ public PlannerFactory(
       final JoinableFactoryWrapper joinableFactoryWrapper,
       final CatalogResolver catalog,
       final AuthConfig authConfig,
+      final PolicyEnforcer policyEnforcer,
       final DruidHookDispatcher hookDispatcher
   )
   {
@@ -96,6 +98,7 @@ public PlannerFactory(
         calciteRuleManager,
         authorizerMapper,
         authConfig,
+        policyEnforcer,
         hookDispatcher
     );
   }
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/PlannerToolbox.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/PlannerToolbox.java
index d8e3a25f4583..17887afd06a5 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/PlannerToolbox.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/PlannerToolbox.java
@@ -22,6 +22,7 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.base.Preconditions;
 import org.apache.druid.math.expr.ExprMacroTable;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.join.JoinableFactoryWrapper;
 import org.apache.druid.server.security.AuthConfig;
 import org.apache.druid.server.security.AuthorizerMapper;
@@ -41,6 +42,7 @@ public class PlannerToolbox
   protected final CalciteRulesManager calciteRuleManager;
   protected final AuthorizerMapper authorizerMapper;
   protected final AuthConfig authConfig;
+  protected final PolicyEnforcer policyEnforcer;
   protected final DruidHookDispatcher hookDispatcher;
 
   public PlannerToolbox(
@@ -55,6 +57,7 @@ public PlannerToolbox(
       final CalciteRulesManager calciteRuleManager,
       final AuthorizerMapper authorizerMapper,
       final AuthConfig authConfig,
+      final PolicyEnforcer policyEnforcer,
       final DruidHookDispatcher hookDispatcher
   )
   {
@@ -69,6 +72,7 @@ public PlannerToolbox(
     this.calciteRuleManager = calciteRuleManager;
     this.authorizerMapper = authorizerMapper;
     this.authConfig = authConfig;
+    this.policyEnforcer = policyEnforcer;
     this.hookDispatcher = hookDispatcher;
   }
 
@@ -122,6 +126,11 @@ public AuthConfig getAuthConfig()
     return authConfig;
   }
 
+  public PolicyEnforcer getPolicyEnforcer()
+  {
+    return policyEnforcer;
+  }
+
   public DruidHookDispatcher getHookDispatcher()
   {
     return hookDispatcher;
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidQuery.java b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidQuery.java
index 067c6c2a0fe5..09790ae75b1d 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidQuery.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidQuery.java
@@ -303,7 +303,10 @@ public static DruidQuery fromPartialQuery(
     }
 
     return new DruidQuery(
-        applyPolicies ? dataSource.withPolicies(plannerContext.getAuthorizationResult().getPolicyMap()) : dataSource,
+        applyPolicies ? dataSource.withPolicies(
+            plannerContext.getAuthorizationResult().getPolicyMap(),
+            plannerContext.getPlannerToolbox().getPolicyEnforcer()
+        ) : dataSource,
         plannerContext,
         filter,
         selectProjection,
diff --git a/sql/src/test/java/org/apache/druid/sql/SqlStatementTest.java b/sql/src/test/java/org/apache/druid/sql/SqlStatementTest.java
index e924102284f3..dfbad004f3ca 100644
--- a/sql/src/test/java/org/apache/druid/sql/SqlStatementTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/SqlStatementTest.java
@@ -19,6 +19,7 @@
 
 package org.apache.druid.sql;
 
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.util.concurrent.ListeningExecutorService;
@@ -37,6 +38,9 @@
 import org.apache.druid.query.Query;
 import org.apache.druid.query.QueryContexts;
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
+import org.apache.druid.query.policy.PolicyEnforcer;
+import org.apache.druid.query.policy.RestrictAllTablesPolicyEnforcer;
 import org.apache.druid.segment.join.JoinableFactoryWrapper;
 import org.apache.druid.server.QueryScheduler;
 import org.apache.druid.server.QueryStackTests;
@@ -78,6 +82,7 @@
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
+import static org.apache.druid.sql.calcite.BaseCalciteQueryTest.assertResultsEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertSame;
@@ -91,12 +96,13 @@ public class SqlStatementTest
   private static Closer resourceCloser;
   @ClassRule
   public static TemporaryFolder temporaryFolder = new TemporaryFolder();
-  private TestRequestLogger testRequestLogger;
   private ListeningExecutorService executorService;
-  private SqlStatementFactory sqlStatementFactory;
   private final DefaultQueryConfig defaultQueryConfig = new DefaultQueryConfig(
       ImmutableMap.of("DEFAULT_KEY", "DEFAULT_VALUE"));
 
+  private PolicyEnforcer policyEnforcer;
+  private SqlStatementFactory sqlStatementFactory;
+
   @BeforeClass
   public static void setUpClass() throws Exception
   {
@@ -135,45 +141,8 @@ public void setUp()
   {
     executorService = MoreExecutors.listeningDecorator(Execs.multiThreaded(8, "test_sql_resource_%s"));
 
-    final PlannerConfig plannerConfig = PlannerConfig.builder().build();
-    final DruidSchemaCatalog rootSchema = CalciteTests.createMockRootSchema(
-        conglomerate,
-        walker,
-        plannerConfig,
-        CalciteTests.TEST_AUTHORIZER_MAPPER
-    );
-    final DruidOperatorTable operatorTable = CalciteTests.createOperatorTable();
-    final ExprMacroTable macroTable = CalciteTests.createExprMacroTable();
-
-    testRequestLogger = new TestRequestLogger();
-    final JoinableFactoryWrapper joinableFactoryWrapper = CalciteTests.createJoinableFactoryWrapper();
-
-    final PlannerFactory plannerFactory = new PlannerFactory(
-        rootSchema,
-        operatorTable,
-        macroTable,
-        plannerConfig,
-        CalciteTests.TEST_AUTHORIZER_MAPPER,
-        CalciteTests.getJsonMapper(),
-        CalciteTests.DRUID_SCHEMA_NAME,
-        new CalciteRulesManager(ImmutableSet.of()),
-        joinableFactoryWrapper,
-        CatalogResolver.NULL_RESOLVER,
-        new AuthConfig(),
-        new DruidHookDispatcher()
-    );
-
-    this.sqlStatementFactory = new SqlStatementFactory(
-        new SqlToolbox(
-            CalciteTests.createMockSqlEngine(walker, conglomerate),
-            plannerFactory,
-            new NoopServiceEmitter(),
-            testRequestLogger,
-            QueryStackTests.DEFAULT_NOOP_SCHEDULER,
-            defaultQueryConfig,
-            new SqlLifecycleManager()
-        )
-    );
+    policyEnforcer = NoopPolicyEnforcer.instance();
+    this.sqlStatementFactory = buildSqlStatementFactory();
   }
 
   @After
@@ -275,6 +244,42 @@ public void testDirectExecTwice()
     }
   }
 
+  @Test
+  public void testDirectPolicyEnforcerThrowsForNoPolicy()
+  {
+    policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    sqlStatementFactory = buildSqlStatementFactory();
+    SqlQueryPlus sqlReq = queryPlus(
+        "SELECT COUNT(*) AS cnt FROM druid.foo",
+        CalciteTests.REGULAR_USER_AUTH_RESULT
+    );
+    DirectStatement stmt = sqlStatementFactory.directStatement(sqlReq);
+    ResultSet resultSet = stmt.plan();
+    DruidException e = Assert.assertThrows(DruidException.class, () -> resultSet.run());
+
+    Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
+    Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
+    Assert.assertEquals("Failed security validation with dataSource [foo]", e.getMessage());
+  }
+
+  @Test
+  public void testDirectPolicyEnforcerValidatesWithPolicy()
+  {
+    policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    sqlStatementFactory = buildSqlStatementFactory();
+    SqlQueryPlus sqlReq = queryPlus(
+        "SELECT COUNT(*) AS cnt FROM druid.restrictedDatasource_m1_is_6",
+        CalciteTests.REGULAR_USER_AUTH_RESULT
+    );
+
+    DirectStatement stmt = sqlStatementFactory.directStatement(sqlReq);
+    ResultSet resultSet = stmt.plan();
+    List<Object[]> results = resultSet.run().getResults().toList();
+
+    ImmutableList<Object[]> expectedResults = ImmutableList.of(new Object[]{1L});
+    assertResultsEquals("SELECT COUNT(*) AS cnt FROM druid.restrictedDatasource_m1_is_6", expectedResults, results);
+  }
+
   @Test
   public void testDirectSyntaxError()
   {
@@ -423,6 +428,38 @@ public void testHttpPermissionError()
     }
   }
 
+  @Test
+  public void testHttpPolicyEnforcerThrowsForNoPolicy() throws Exception
+  {
+    policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    sqlStatementFactory = buildSqlStatementFactory();
+    HttpStatement stmt = sqlStatementFactory.httpStatement(
+        makeQuery("SELECT COUNT(*) AS cnt FROM druid.foo"),
+        request(true)
+    );
+    ResultSet resultSet = stmt.plan();
+    DruidException e = Assert.assertThrows(DruidException.class, () -> resultSet.run());
+
+    Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
+    Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
+    Assert.assertEquals("Failed security validation with dataSource [foo]", e.getMessage());
+  }
+
+  @Test
+  public void testHttpPolicyEnforcerValidatesWithPolicy()
+  {
+    policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    sqlStatementFactory = buildSqlStatementFactory();
+    HttpStatement stmt = sqlStatementFactory.httpStatement(
+        makeQuery("SELECT COUNT(*) AS cnt FROM druid.restrictedDatasource_m1_is_6"),
+        request(true)
+    );
+    List<Object[]> results = stmt.plan().run().getResults().toList();
+
+    ImmutableList<Object[]> expectedResults = ImmutableList.of(new Object[]{1L});
+    assertResultsEquals("SELECT COUNT(*) AS cnt FROM druid.restrictedDatasource_m1_is_6", expectedResults, results);
+  }
+
   //-----------------------------------------------------------------
   // Prepared statements: using a prepare/execute model.
 
@@ -518,6 +555,39 @@ public void testPreparePermissionError()
     }
   }
 
+  @Test
+  public void testPreparePolicyEnforcerThrowsForNoPolicy() throws Exception
+  {
+    policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    sqlStatementFactory = buildSqlStatementFactory();
+    SqlQueryPlus sqlReq = queryPlus(
+        "SELECT COUNT(*) AS cnt FROM druid.foo",
+        CalciteTests.REGULAR_USER_AUTH_RESULT
+    );
+    PreparedStatement stmt = sqlStatementFactory.preparedStatement(sqlReq);
+    DruidException e = Assert.assertThrows(DruidException.class, () -> stmt.execute(Collections.emptyList()).execute());
+
+    Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
+    Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
+    Assert.assertEquals("Failed security validation with dataSource [foo]", e.getMessage());
+  }
+
+  @Test
+  public void testPreparePolicyEnforcerValidatesWithPolicy()
+  {
+    policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    sqlStatementFactory = buildSqlStatementFactory();
+    SqlQueryPlus sqlReq = queryPlus(
+        "SELECT COUNT(*) AS cnt FROM druid.restrictedDatasource_m1_is_6",
+        CalciteTests.REGULAR_USER_AUTH_RESULT
+    );
+    PreparedStatement stmt = sqlStatementFactory.preparedStatement(sqlReq);
+    List<Object[]> results = stmt.execute(Collections.emptyList()).execute().getResults().toList();
+
+    ImmutableList<Object[]> expectedResults = ImmutableList.of(new Object[]{1L});
+    assertResultsEquals("SELECT COUNT(*) AS cnt FROM druid.restrictedDatasource_m1_is_6", expectedResults, results);
+  }
+
   //-----------------------------------------------------------------
   // Generic tests.
 
@@ -552,4 +622,48 @@ public void testDefaultQueryContextIsApplied()
       Assert.assertTrue(context.containsKey(defaultContextKey));
     }
   }
+
+  private SqlStatementFactory buildSqlStatementFactory()
+  {
+    final PlannerConfig plannerConfig = PlannerConfig.builder().build();
+    final DruidSchemaCatalog rootSchema = CalciteTests.createMockRootSchema(
+        conglomerate,
+        walker,
+        plannerConfig,
+        CalciteTests.TEST_AUTHORIZER_MAPPER
+    );
+    final DruidOperatorTable operatorTable = CalciteTests.createOperatorTable();
+    final ExprMacroTable macroTable = CalciteTests.createExprMacroTable();
+
+    TestRequestLogger testRequestLogger = new TestRequestLogger();
+    final JoinableFactoryWrapper joinableFactoryWrapper = CalciteTests.createJoinableFactoryWrapper();
+
+    final PlannerFactory plannerFactory = new PlannerFactory(
+        rootSchema,
+        operatorTable,
+        macroTable,
+        plannerConfig,
+        CalciteTests.TEST_AUTHORIZER_MAPPER,
+        CalciteTests.getJsonMapper(),
+        CalciteTests.DRUID_SCHEMA_NAME,
+        new CalciteRulesManager(ImmutableSet.of()),
+        joinableFactoryWrapper,
+        CatalogResolver.NULL_RESOLVER,
+        new AuthConfig(),
+        policyEnforcer,
+        new DruidHookDispatcher()
+    );
+
+    return new SqlStatementFactory(
+        new SqlToolbox(
+            CalciteTests.createMockSqlEngine(walker, conglomerate),
+            plannerFactory,
+            new NoopServiceEmitter(),
+            testRequestLogger,
+            QueryStackTests.DEFAULT_NOOP_SCHEDULER,
+            defaultQueryConfig,
+            new SqlLifecycleManager()
+        )
+    );
+  }
 }
diff --git a/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java b/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java
index 50f05fd98fe9..653f8abf31fb 100644
--- a/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java
@@ -55,6 +55,7 @@
 import org.apache.druid.query.BaseQuery;
 import org.apache.druid.query.DefaultQueryConfig;
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.segment.join.JoinableFactoryWrapper;
 import org.apache.druid.server.DruidNode;
 import org.apache.druid.server.QueryLifecycleFactory;
@@ -1059,6 +1060,7 @@ private SqlStatementFactory makeStatementFactory()
             CalciteTests.createJoinableFactoryWrapper(),
             CatalogResolver.NULL_RESOLVER,
             new AuthConfig(),
+            NoopPolicyEnforcer.instance(),
             new DruidHookDispatcher()
         )
     );
diff --git a/sql/src/test/java/org/apache/druid/sql/avatica/DruidStatementTest.java b/sql/src/test/java/org/apache/druid/sql/avatica/DruidStatementTest.java
index 94b20eb9d65f..b74362d7df29 100644
--- a/sql/src/test/java/org/apache/druid/sql/avatica/DruidStatementTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/avatica/DruidStatementTest.java
@@ -29,6 +29,7 @@
 import org.apache.druid.java.util.common.io.Closer;
 import org.apache.druid.math.expr.ExprMacroTable;
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.segment.join.JoinableFactoryWrapper;
 import org.apache.druid.server.QueryStackTests;
 import org.apache.druid.server.SpecificSegmentsQuerySegmentWalker;
@@ -113,6 +114,7 @@ public void setUp()
         joinableFactoryWrapper,
         CatalogResolver.NULL_RESOLVER,
         new AuthConfig(),
+        NoopPolicyEnforcer.instance(),
         new DruidHookDispatcher()
     );
     this.sqlStatementFactory = CalciteTests.createSqlStatementFactory(
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/SqlVectorizedExpressionSanityTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/SqlVectorizedExpressionSanityTest.java
index 07f57a5deeb3..26b125bf6576 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/SqlVectorizedExpressionSanityTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/SqlVectorizedExpressionSanityTest.java
@@ -31,6 +31,7 @@
 import org.apache.druid.java.util.common.logger.Logger;
 import org.apache.druid.query.QueryContexts;
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.segment.QueryableIndex;
 import org.apache.druid.segment.generator.GeneratorBasicSchemas;
 import org.apache.druid.segment.generator.GeneratorSchemaInfo;
@@ -154,6 +155,7 @@ public static void setupClass()
         joinableFactoryWrapper,
         CatalogResolver.NULL_RESOLVER,
         new AuthConfig(),
+        NoopPolicyEnforcer.instance(),
         new DruidHookDispatcher()
     );
   }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionTestHelper.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionTestHelper.java
index f4ada1f1c179..20d7c0fa0786 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionTestHelper.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionTestHelper.java
@@ -37,6 +37,7 @@
 import org.apache.druid.math.expr.ExpressionType;
 import org.apache.druid.query.filter.DimFilter;
 import org.apache.druid.query.filter.ValueMatcher;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.segment.RowAdapters;
 import org.apache.druid.segment.RowBasedColumnSelectorFactory;
 import org.apache.druid.segment.VirtualColumn;
@@ -99,6 +100,7 @@ NamedViewSchema.NAME, new NamedViewSchema(EasyMock.createMock(ViewSchema.class))
       new CalciteRulesManager(ImmutableSet.of()),
       CalciteTests.TEST_AUTHORIZER_MAPPER,
       AuthConfig.newBuilder().build(),
+      NoopPolicyEnforcer.instance(),
       new DruidHookDispatcher()
   );
   public static final PlannerContext PLANNER_CONTEXT = PlannerContext.create(
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/external/ExternalTableScanRuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/external/ExternalTableScanRuleTest.java
index fe26ba9db8c7..4f30cc1feb11 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/external/ExternalTableScanRuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/external/ExternalTableScanRuleTest.java
@@ -26,6 +26,7 @@
 import org.apache.calcite.schema.SchemaPlus;
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
 import org.apache.druid.query.QuerySegmentWalker;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.server.security.AuthConfig;
 import org.apache.druid.sql.calcite.planner.CalciteRulesManager;
 import org.apache.druid.sql.calcite.planner.CatalogResolver;
@@ -73,6 +74,7 @@ NamedViewSchema.NAME, new NamedViewSchema(EasyMock.createMock(ViewSchema.class))
         new CalciteRulesManager(ImmutableSet.of()),
         CalciteTests.TEST_AUTHORIZER_MAPPER,
         AuthConfig.newBuilder().build(),
+        NoopPolicyEnforcer.instance(),
         new DruidHookDispatcher()
     );
     final PlannerContext plannerContext = PlannerContext.create(
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitePlannerModuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitePlannerModuleTest.java
index 89df405b7f1f..52aadd54839c 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitePlannerModuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitePlannerModuleTest.java
@@ -33,12 +33,12 @@
 import org.apache.calcite.rel.rules.ProjectMergeRule;
 import org.apache.calcite.schema.Schema;
 import org.apache.druid.guice.LazySingleton;
+import org.apache.druid.guice.security.PolicyModule;
 import org.apache.druid.jackson.DefaultObjectMapper;
 import org.apache.druid.jackson.JacksonModule;
 import org.apache.druid.math.expr.ExprMacroTable;
 import org.apache.druid.segment.join.JoinableFactoryWrapper;
 import org.apache.druid.server.QueryLifecycleFactory;
-import org.apache.druid.server.security.AuthConfig;
 import org.apache.druid.server.security.AuthorizerMapper;
 import org.apache.druid.server.security.ResourceType;
 import org.apache.druid.sql.calcite.aggregation.SqlAggregator;
@@ -49,8 +49,6 @@
 import org.apache.druid.sql.calcite.schema.DruidSchemaName;
 import org.apache.druid.sql.calcite.schema.NamedSchema;
 import org.apache.druid.sql.calcite.util.CalciteTestBase;
-import org.apache.druid.sql.calcite.util.CalciteTests;
-import org.apache.druid.sql.hook.DruidHookDispatcher;
 import org.easymock.EasyMock;
 import org.easymock.EasyMockExtension;
 import org.easymock.Mock;
@@ -127,6 +125,7 @@ public void onMatch(RelOptRuleCall call)
     };
     injector = Guice.createInjector(
         new JacksonModule(),
+        new PolicyModule(),
         binder -> {
           binder.bind(Validator.class).toInstance(Validation.buildDefaultValidatorFactory().getValidator());
           binder.bindScope(LazySingleton.class, Scopes.SINGLETON);
@@ -182,20 +181,7 @@ public void testPlannerConfigIsInjected()
   public void testExtensionCalciteRule()
   {
     ObjectMapper mapper = new DefaultObjectMapper();
-    PlannerToolbox toolbox = new PlannerToolbox(
-        injector.getInstance(DruidOperatorTable.class),
-        macroTable,
-        mapper,
-        injector.getInstance(PlannerConfig.class),
-        rootSchema,
-        joinableFactoryWrapper,
-        CatalogResolver.NULL_RESOLVER,
-        "druid",
-        new CalciteRulesManager(ImmutableSet.of()),
-        CalciteTests.TEST_AUTHORIZER_MAPPER,
-        AuthConfig.newBuilder().build(),
-        new DruidHookDispatcher()
-    );
+    PlannerToolbox toolbox = injector.getInstance(PlannerFactory.class);
 
     PlannerContext context = PlannerContext.create(
         toolbox,
@@ -215,20 +201,7 @@ public void testExtensionCalciteRule()
   public void testConfigurableBloat()
   {
     ObjectMapper mapper = new DefaultObjectMapper();
-    PlannerToolbox toolbox = new PlannerToolbox(
-            injector.getInstance(DruidOperatorTable.class),
-            macroTable,
-            mapper,
-            injector.getInstance(PlannerConfig.class),
-            rootSchema,
-            joinableFactoryWrapper,
-            CatalogResolver.NULL_RESOLVER,
-            "druid",
-            new CalciteRulesManager(ImmutableSet.of()),
-            CalciteTests.TEST_AUTHORIZER_MAPPER,
-            AuthConfig.newBuilder().build(),
-            new DruidHookDispatcher()
-    );
+    PlannerToolbox toolbox = injector.getInstance(PlannerFactory.class);
 
     PlannerContext contextWithBloat = PlannerContext.create(
             toolbox,
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java
index 7888ec8090ba..816ce3fd1a1d 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java
@@ -39,6 +39,7 @@
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.column.RowSignature;
 import org.apache.druid.server.security.AuthConfig;
@@ -105,6 +106,7 @@ NamedViewSchema.NAME, new NamedViewSchema(EasyMock.createMock(ViewSchema.class))
       new CalciteRulesManager(ImmutableSet.of()),
       CalciteTests.TEST_AUTHORIZER_MAPPER,
       AuthConfig.newBuilder().build(),
+      NoopPolicyEnforcer.instance(),
       new DruidHookDispatcher()
   );
   private static final PlannerContext PLANNER_CONTEXT = PlannerContext.create(
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/QueryFrameworkUtils.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/QueryFrameworkUtils.java
index 67b5b9d11e22..39e1b4f41307 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/util/QueryFrameworkUtils.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/QueryFrameworkUtils.java
@@ -35,6 +35,7 @@
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
 import org.apache.druid.query.QuerySegmentWalker;
 import org.apache.druid.query.lookup.LookupExtractorFactoryContainerProvider;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.segment.join.JoinableFactory;
 import org.apache.druid.segment.loading.SegmentCacheManager;
 import org.apache.druid.segment.metadata.CentralizedDatasourceSchemaConfig;
@@ -96,6 +97,7 @@ public static QueryLifecycleFactory createMockQueryLifecycleFactory(
         new ServiceEmitter("dummy", "dummy", new NoopEmitter()),
         new NoopRequestLogger(),
         new AuthConfig(),
+        NoopPolicyEnforcer.instance(),
         authorizerMapper,
         Suppliers.ofInstance(new DefaultQueryConfig(ImmutableMap.of()))
     );
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
index e09e60bd0640..04d1d3b2948c 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
@@ -73,6 +73,7 @@
 import org.apache.druid.query.groupby.GroupingEngine;
 import org.apache.druid.query.groupby.TestGroupByBuffers;
 import org.apache.druid.query.lookup.LookupExtractorFactoryContainerProvider;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.topn.TopNQueryConfig;
 import org.apache.druid.quidem.ProjectPathUtils;
 import org.apache.druid.quidem.TestSqlModule;
@@ -852,6 +853,7 @@ public PlannerFixture(
           framework.injector.getInstance(JoinableFactoryWrapper.class),
           framework.builder.catalogResolver,
           authConfig != null ? authConfig : new AuthConfig(),
+          NoopPolicyEnforcer.instance(),
           new DruidHookDispatcher()
       );
       componentSupplier.finalizePlanner(this);
diff --git a/sql/src/test/java/org/apache/druid/sql/http/SqlResourceTest.java b/sql/src/test/java/org/apache/druid/sql/http/SqlResourceTest.java
index 8168fb53683d..8b767de3b5a5 100644
--- a/sql/src/test/java/org/apache/druid/sql/http/SqlResourceTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/http/SqlResourceTest.java
@@ -63,6 +63,7 @@
 import org.apache.druid.query.ResourceLimitExceededException;
 import org.apache.druid.query.context.ResponseContext;
 import org.apache.druid.query.groupby.GroupByQueryConfig;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.server.DruidNode;
 import org.apache.druid.server.QueryResource;
 import org.apache.druid.server.QueryResponse;
@@ -259,6 +260,7 @@ public void setUp() throws Exception
         CalciteTests.createJoinableFactoryWrapper(),
         CatalogResolver.NULL_RESOLVER,
         new AuthConfig(),
+        NoopPolicyEnforcer.instance(),
         new DruidHookDispatcher()
     );
 

From ce841d1afe64dbb63be553edb5ffcbe971e88889 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Thu, 10 Apr 2025 18:51:19 -0700
Subject: [PATCH 88/99] fix binding and test

---
 .../guice/security/PolicyModuleTest.java      | 37 +++++++------------
 .../sql/avatica/DruidAvaticaHandlerTest.java  |  2 +
 2 files changed, 15 insertions(+), 24 deletions(-)

diff --git a/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java b/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
index 86f9df62f675..9c524235fb17 100644
--- a/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
+++ b/server/src/test/java/org/apache/druid/guice/security/PolicyModuleTest.java
@@ -27,9 +27,12 @@
 import org.apache.druid.guice.ConfigModule;
 import org.apache.druid.guice.DruidGuiceExtensions;
 import org.apache.druid.jackson.JacksonModule;
+import org.apache.druid.query.filter.NullFilter;
+import org.apache.druid.query.policy.NoRestrictionPolicy;
 import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.query.policy.RestrictAllTablesPolicyEnforcer;
+import org.apache.druid.query.policy.RowFilterPolicy;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -94,7 +97,10 @@ public void testConfigRestrictAllTablesPolicyEnforcerWithAllowedPolicies()
   {
     Properties properties = new Properties();
     properties.setProperty("druid.policy.enforcer.type", "restrictAllTables");
-    properties.setProperty("druid.policy.enforcer.allowedPolicies", "[\"some-policy-class\"]");
+    properties.setProperty(
+        "druid.policy.enforcer.allowedPolicies",
+        "[\"some-policy-class\", \"org.apache.druid.query.policy.NoRestrictionPolicy\"]"
+    );
     PolicyEnforcer policyEnforcer = Guice.createInjector(
         binder -> binder.bind(Properties.class).toInstance(properties),
         new DruidGuiceExtensions(),
@@ -104,28 +110,11 @@ public void testConfigRestrictAllTablesPolicyEnforcerWithAllowedPolicies()
     ).getInstance(Key.get(PolicyEnforcer.class));
 
     Assert.assertNotNull(policyEnforcer);
-    Assert.assertEquals(new RestrictAllTablesPolicyEnforcer(ImmutableList.of("some-policy-class")), policyEnforcer);
-  }
-
-  @Test
-  public void testConfigRestrictAllTablesPolicyEnforcerThrowWithUnrecognizedPolicyClazz()
-  {
-    Properties properties = new Properties();
-    properties.setProperty("druid.policy.enforcer.type", "restrictAllTables");
-    properties.setProperty("druid.policy.enforcer.allowedPolicies", "[\"UnrecognizedPolicy\"]");
-
-    Injector injector = Guice.createInjector(
-        binder -> binder.bind(Properties.class).toInstance(properties),
-        new DruidGuiceExtensions(),
-        new ConfigModule(),
-        new JacksonModule(),
-        new PolicyModule()
-    );
-
-    ProvisionException e = Assert.assertThrows(
-        ProvisionException.class,
-        () -> injector.getInstance(Key.get(PolicyEnforcer.class))
-    );
-    Assert.assertTrue(e.getCause().getMessage().contains("Unrecognized class[[UnrecognizedPolicy]]"));
+    Assert.assertEquals(new RestrictAllTablesPolicyEnforcer(ImmutableList.of(
+        "some-policy-class",
+        "org.apache.druid.query.policy.NoRestrictionPolicy"
+    )), policyEnforcer);
+    Assert.assertTrue(policyEnforcer.validate(NoRestrictionPolicy.instance()));
+    Assert.assertFalse(policyEnforcer.validate(RowFilterPolicy.from(new NullFilter("some-col", null))));
   }
 }
diff --git a/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java b/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java
index 653f8abf31fb..0aae1021bb10 100644
--- a/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java
@@ -42,6 +42,7 @@
 import org.apache.calcite.avatica.server.AbstractAvaticaHandler;
 import org.apache.druid.guice.LazySingleton;
 import org.apache.druid.guice.StartupInjectorBuilder;
+import org.apache.druid.guice.security.PolicyModule;
 import org.apache.druid.initialization.CoreInjectorBuilder;
 import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.java.util.common.Pair;
@@ -274,6 +275,7 @@ public void setUp() throws Exception
               binder.bind(AuthenticatorMapper.class).toInstance(CalciteTests.TEST_AUTHENTICATOR_MAPPER);
               binder.bind(AuthorizerMapper.class).toInstance(CalciteTests.TEST_AUTHORIZER_MAPPER);
               binder.bind(Escalator.class).toInstance(CalciteTests.TEST_AUTHENTICATOR_ESCALATOR);
+              binder.install(new PolicyModule());
               binder.bind(RequestLogger.class).toInstance(testRequestLogger);
               binder.bind(DruidSchemaCatalog.class).toInstance(rootSchema);
               for (NamedSchema schema : rootSchema.getNamedSchemas().values()) {

From a7958eb85f0c9dfa2315be69f93083904bd9162f Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Thu, 10 Apr 2025 19:54:11 -0700
Subject: [PATCH 89/99] add policy module

---
 sql/src/test/java/org/apache/druid/sql/guice/SqlModuleTest.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/sql/src/test/java/org/apache/druid/sql/guice/SqlModuleTest.java b/sql/src/test/java/org/apache/druid/sql/guice/SqlModuleTest.java
index b4437045fe1a..84629a90810a 100644
--- a/sql/src/test/java/org/apache/druid/sql/guice/SqlModuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/guice/SqlModuleTest.java
@@ -41,6 +41,7 @@
 import org.apache.druid.guice.LifecycleModule;
 import org.apache.druid.guice.PolyBind;
 import org.apache.druid.guice.ServerModule;
+import org.apache.druid.guice.security.PolicyModule;
 import org.apache.druid.initialization.DruidModule;
 import org.apache.druid.jackson.JacksonModule;
 import org.apache.druid.java.util.emitter.service.ServiceEmitter;
@@ -185,6 +186,7 @@ private Injector makeInjectorWithProperties(final Properties props)
             new LifecycleModule(),
             new ServerModule(),
             new JacksonModule(),
+            new PolicyModule(),
             new AuthenticatorMapperModule(),
             binder -> {
               binder.bind(Validator.class).toInstance(Validation.buildDefaultValidatorFactory().getValidator());

From 3586ee1efe121e4528070cfb3019784e4abf6f5d Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Thu, 10 Apr 2025 20:00:13 -0700
Subject: [PATCH 90/99] mock planner toolbox

---
 .../appenderator/StreamAppenderatorTest.java  | 43 -------------------
 .../druid/sql/calcite/rel/DruidRelTest.java   |  5 +++
 2 files changed, 5 insertions(+), 43 deletions(-)

diff --git a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTest.java b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTest.java
index 0f06abe4afb9..72a221e9040a 100644
--- a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTest.java
+++ b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTest.java
@@ -29,7 +29,6 @@
 import org.apache.druid.data.input.Committer;
 import org.apache.druid.data.input.InputRow;
 import org.apache.druid.data.input.MapBasedInputRow;
-import org.apache.druid.error.DruidException;
 import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.Pair;
@@ -39,15 +38,10 @@
 import org.apache.druid.query.Druids;
 import org.apache.druid.query.Order;
 import org.apache.druid.query.QueryPlus;
-import org.apache.druid.query.RestrictedDataSource;
 import org.apache.druid.query.Result;
 import org.apache.druid.query.SegmentDescriptor;
-import org.apache.druid.query.TableDataSource;
 import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
 import org.apache.druid.query.context.ResponseContext;
-import org.apache.druid.query.policy.NoRestrictionPolicy;
-import org.apache.druid.query.policy.PolicyEnforcer;
-import org.apache.druid.query.policy.RestrictAllTablesPolicyEnforcer;
 import org.apache.druid.query.scan.ScanQuery;
 import org.apache.druid.query.scan.ScanResultValue;
 import org.apache.druid.query.spec.MultipleSpecificSegmentSpec;
@@ -2228,43 +2222,6 @@ public void testQueryBySegments() throws Exception
     }
   }
 
-  @Test
-  public void testQueryThrowOnPolicyEnforcerValidationFailure() throws Exception
-  {
-    final PolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
-    final StreamAppenderatorTester tester = new StreamAppenderatorTester.Builder().maxRowsInMemory(2)
-                                                                                  .basePersistDirectory(temporaryFolder.newFolder())
-                                                                                  .withPolicyEnforcer(policyEnforcer)
-                                                                                  .build();
-    final Appenderator appenderator = tester.getAppenderator();
-
-    // Query on table, fail with policy enforcer
-    final TimeseriesQuery query = Druids.newTimeseriesQueryBuilder()
-                                        .dataSource(StreamAppenderatorTester.DATASOURCE)
-                                        .granularity(Granularities.DAY)
-                                        .intervals(Intervals.ONLY_ETERNITY)
-                                        .build();
-    DruidException e = Assert.assertThrows(
-        DruidException.class,
-        () -> QueryPlus.wrap(query).run(appenderator, ResponseContext.createEmpty())
-    );
-    Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
-    Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
-    Assert.assertEquals("Failed security validation with dataSource [foo]", e.getMessage());
-
-    // Query on restricted, success
-    final RestrictedDataSource restricted = RestrictedDataSource.create(
-        TableDataSource.create(StreamAppenderatorTester.DATASOURCE),
-        NoRestrictionPolicy.instance());
-    final TimeseriesQuery queryOnRestricted = Druids.newTimeseriesQueryBuilder()
-                                        .dataSource(restricted)
-                                        .granularity(Granularities.DAY)
-                                        .intervals(Intervals.ONLY_ETERNITY)
-                                        .build();
-    Assert.assertNotNull(QueryPlus.wrap(queryOnRestricted).run(appenderator, ResponseContext.createEmpty()).toList());
-
-  }
-
   private void verifySinkMetrics(StubServiceEmitter emitter, Set<String> segmentIds)
   {
     Map<String, List<StubServiceEmitter.ServiceMetricEventSnapshot>> events = emitter.getMetricEvents();
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelTest.java
index 549484b5f9a9..292ba32cff88 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelTest.java
@@ -53,6 +53,7 @@
 import org.apache.druid.query.TableDataSource;
 import org.apache.druid.query.UnionDataSource;
 import org.apache.druid.query.UnnestDataSource;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.policy.Policy;
 import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.column.RowSignature;
@@ -60,6 +61,7 @@
 import org.apache.druid.sql.calcite.planner.ExpressionParser;
 import org.apache.druid.sql.calcite.planner.PlannerConfig;
 import org.apache.druid.sql.calcite.planner.PlannerContext;
+import org.apache.druid.sql.calcite.planner.PlannerToolbox;
 import org.apache.druid.sql.calcite.rel.logical.DruidUnion;
 import org.apache.druid.sql.calcite.table.DatasourceTable;
 import org.apache.druid.sql.calcite.table.DatasourceTable.PhysicalDatasourceMetadata;
@@ -121,6 +123,9 @@ public void setup() throws Exception
     when(mockRelOptCluster.getTypeFactory()).thenReturn(DEFAULT_TYPE_FACTORY);
     when(mockRelOptTable.getRowType()).thenReturn(REC_TYPE);
 
+    PlannerToolbox mockPlannerToolbox = mock(PlannerToolbox.class);
+    when(mockPlannerToolbox.getPolicyEnforcer()).thenReturn(NoopPolicyEnforcer.instance());
+    when(mockPlannerContext.getPlannerToolbox()).thenReturn(mockPlannerToolbox);
     when(mockPlannerContext.getPlannerConfig()).thenReturn(PlannerConfig.builder().build());
     when(mockPlannerContext.getJsonMapper()).thenReturn(JsonMapper.builder().build());
     when(mockPlannerContext.getAuthorizationResult()).thenReturn(AUTHORIZATION_RESULT);

From 5658bf7a10e997afa6622552634b68597f7e06da Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Fri, 11 Apr 2025 10:49:07 -0700
Subject: [PATCH 91/99] revert some injection

---
 .../druid/msq/sql/MSQTaskQueryMaker.java      |  3 -
 .../druid/msq/sql/MSQTaskSqlEngine.java       |  5 --
 .../druid/msq/exec/TestMSQSqlModule.java      |  1 -
 .../msq/querykit/FrameProcessorTestBase.java  |  2 +-
 .../druid/msq/sql/MSQTaskQueryMakerTest.java  | 73 +++++--------------
 .../apache/druid/msq/test/MSQTestBase.java    |  1 -
 processing/pom.xml                            |  2 +-
 .../segment/ReferenceCountingSegment.java     |  2 +-
 .../druid/segment/InlineSegmentWrangler.java  |  2 +-
 9 files changed, 23 insertions(+), 68 deletions(-)

diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java
index d50bace8dda0..2e9c431959ed 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java
@@ -99,7 +99,6 @@ public class MSQTaskQueryMaker implements QueryMaker
   private final IngestDestination targetDataSource;
   private final OverlordClient overlordClient;
   private final PlannerContext plannerContext;
-  private final PolicyEnforcer policyEnforcer;
   private final ObjectMapper jsonMapper;
   private final List<Entry<Integer, String>> fieldMapping;
   private final MSQTerminalStageSpecFactory terminalStageSpecFactory;
@@ -108,7 +107,6 @@ public class MSQTaskQueryMaker implements QueryMaker
       @Nullable final IngestDestination targetDataSource,
       final OverlordClient overlordClient,
       final PlannerContext plannerContext,
-      final PolicyEnforcer policyEnforcer,
       final ObjectMapper jsonMapper,
       final List<Entry<Integer, String>> fieldMapping,
       final MSQTerminalStageSpecFactory terminalStageSpecFactory
@@ -117,7 +115,6 @@ public class MSQTaskQueryMaker implements QueryMaker
     this.targetDataSource = targetDataSource;
     this.overlordClient = Preconditions.checkNotNull(overlordClient, "indexingServiceClient");
     this.plannerContext = Preconditions.checkNotNull(plannerContext, "plannerContext");
-    this.policyEnforcer = Preconditions.checkNotNull(policyEnforcer, "policyEnforcer");
     this.jsonMapper = Preconditions.checkNotNull(jsonMapper, "jsonMapper");
     this.fieldMapping = Preconditions.checkNotNull(fieldMapping, "fieldMapping");
     this.terminalStageSpecFactory = terminalStageSpecFactory;
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskSqlEngine.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskSqlEngine.java
index fa2ca9869793..6a100f685b5c 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskSqlEngine.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskSqlEngine.java
@@ -90,20 +90,17 @@ public class MSQTaskSqlEngine implements SqlEngine
   private static final String NAME = "msq-task";
 
   private final OverlordClient overlordClient;
-  private final PolicyEnforcer policyEnforcer;
   private final ObjectMapper jsonMapper;
   private final MSQTerminalStageSpecFactory terminalStageSpecFactory;
 
   @Inject
   public MSQTaskSqlEngine(
       final OverlordClient overlordClient,
-      final PolicyEnforcer policyEnforcer,
       final ObjectMapper jsonMapper,
       final MSQTerminalStageSpecFactory terminalStageSpecFactory
   )
   {
     this.overlordClient = overlordClient;
-    this.policyEnforcer = policyEnforcer;
     this.jsonMapper = jsonMapper;
     this.terminalStageSpecFactory = terminalStageSpecFactory;
   }
@@ -181,7 +178,6 @@ public QueryMaker buildQueryMakerForSelect(
         null,
         overlordClient,
         plannerContext,
-        policyEnforcer,
         jsonMapper,
         relRoot.fields,
         terminalStageSpecFactory
@@ -216,7 +212,6 @@ public QueryMaker buildQueryMakerForInsert(
         destination,
         overlordClient,
         plannerContext,
-        policyEnforcer,
         jsonMapper,
         relRoot.fields,
         terminalStageSpecFactory
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/TestMSQSqlModule.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/TestMSQSqlModule.java
index b4c9e0e152c3..0e44570b49db 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/TestMSQSqlModule.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/TestMSQSqlModule.java
@@ -55,7 +55,6 @@ public MSQTaskSqlEngine createEngine(ObjectMapper queryJsonMapper, MSQTestOverlo
   {
     return new MSQTaskSqlEngine(
         indexingServiceClient,
-        NoopPolicyEnforcer.instance(),
         queryJsonMapper,
         new SegmentGenerationTerminalStageSpecFactory()
     );
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/FrameProcessorTestBase.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/FrameProcessorTestBase.java
index 6ae3e7ec4efc..cde2b0ea4e9d 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/FrameProcessorTestBase.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/FrameProcessorTestBase.java
@@ -52,7 +52,7 @@ public class FrameProcessorTestBase extends InitializedNullHandlingTest
   protected FrameProcessorExecutor exec;
 
   @Before
-  public void setUp() throws Exception
+  public void setUp()
   {
     innerExec = MoreExecutors.listeningDecorator(Execs.singleThreaded("test-exec"));
     exec = new FrameProcessorExecutor(innerExec);
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
index f4bd42b98569..3f99a52e314b 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
@@ -223,15 +223,7 @@ public void testSimpleScanQuery() throws Exception
                                                .build();
     DruidQuery druidQueryMock = buildDruidQueryMock(query, resultSignature);
     // Act
-    msqTaskQueryMaker = new MSQTaskQueryMaker(
-        ingestDestination,
-        fakeOverlordClient,
-        plannerContextMock,
-        policyEnforcer,
-        objectMapper,
-        fieldMapping,
-        terminalStageSpecFactory
-    );
+    msqTaskQueryMaker = getMSQTaskQueryMaker();
     QueryResponse<Object[]> response = msqTaskQueryMaker.runQuery(druidQueryMock);
     // Assert
     String taskId = (String) Iterables.getOnlyElement(response.getResults().toList())[0];
@@ -269,15 +261,7 @@ public void testScanQueryFailWithPolicyValidation() throws Exception
                                                .build();
     DruidQuery druidQueryMock = buildDruidQueryMock(query, resultSignature);
     // Act
-    msqTaskQueryMaker = new MSQTaskQueryMaker(
-        ingestDestination,
-        fakeOverlordClient,
-        plannerContextMock,
-        policyEnforcer,
-        objectMapper,
-        fieldMapping,
-        terminalStageSpecFactory
-    );
+    msqTaskQueryMaker = getMSQTaskQueryMaker();
     QueryResponse<Object[]> response = msqTaskQueryMaker.runQuery(druidQueryMock);
     // Assert
     String taskId = (String) Iterables.getOnlyElement(response.getResults().toList())[0];
@@ -318,15 +302,7 @@ public void testScanQueryPassedPolicyValidation() throws Exception
                                                .build();
     DruidQuery druidQueryMock = buildDruidQueryMock(query, resultSignature);
     // Act
-    msqTaskQueryMaker = new MSQTaskQueryMaker(
-        ingestDestination,
-        fakeOverlordClient,
-        plannerContextMock,
-        policyEnforcer,
-        objectMapper,
-        fieldMapping,
-        terminalStageSpecFactory
-    );
+    msqTaskQueryMaker = getMSQTaskQueryMaker();
     QueryResponse<Object[]> response = msqTaskQueryMaker.runQuery(druidQueryMock);
     // Assert
     String taskId = (String) Iterables.getOnlyElement(response.getResults().toList())[0];
@@ -374,15 +350,7 @@ public void testUnnestOnRestrictedPassedPolicyValidation() throws Exception
                                                .build();
     DruidQuery druidQueryMock = buildDruidQueryMock(query, resultSignature);
     // Act
-    msqTaskQueryMaker = new MSQTaskQueryMaker(
-        ingestDestination,
-        fakeOverlordClient,
-        plannerContextMock,
-        policyEnforcer,
-        objectMapper,
-        fieldMapping,
-        terminalStageSpecFactory
-    );
+    msqTaskQueryMaker = getMSQTaskQueryMaker();
     QueryResponse<Object[]> response = msqTaskQueryMaker.runQuery(druidQueryMock);
     // Assert
     String taskId = (String) Iterables.getOnlyElement(response.getResults().toList())[0];
@@ -420,15 +388,7 @@ public void testInlineDataSourcePassedPolicyValidation() throws Exception
                                                .build();
     DruidQuery druidQueryMock = buildDruidQueryMock(query, resultSignature);
     // Act
-    msqTaskQueryMaker = new MSQTaskQueryMaker(
-        ingestDestination,
-        fakeOverlordClient,
-        plannerContextMock,
-        policyEnforcer,
-        objectMapper,
-        fieldMapping,
-        terminalStageSpecFactory
-    );
+    msqTaskQueryMaker = getMSQTaskQueryMaker();
     QueryResponse<Object[]> response = msqTaskQueryMaker.runQuery(druidQueryMock);
     // Assert
     String taskId = (String) Iterables.getOnlyElement(response.getResults().toList())[0];
@@ -457,15 +417,7 @@ public void testLookupDataSourcePassedPolicyValidation() throws Exception
                                                .build();
     DruidQuery druidQueryMock = buildDruidQueryMock(query, resultSignature);
     // Act
-    msqTaskQueryMaker = new MSQTaskQueryMaker(
-        ingestDestination,
-        fakeOverlordClient,
-        plannerContextMock,
-        policyEnforcer,
-        objectMapper,
-        fieldMapping,
-        terminalStageSpecFactory
-    );
+    msqTaskQueryMaker = getMSQTaskQueryMaker();
     QueryResponse<Object[]> response = msqTaskQueryMaker.runQuery(druidQueryMock);
     // Assert
     String taskId = (String) Iterables.getOnlyElement(response.getResults().toList())[0];
@@ -502,4 +454,17 @@ private static List<Map.Entry<Integer, String>> buildFieldMapping(RowSignature r
                                          .collect(toMap(Function.identity(), columns::get))
                                          .entrySet());
   }
+
+  private MSQTaskQueryMaker getMSQTaskQueryMaker()
+  {
+    // This can't be in setUp() because the fieldMapping are set in the test
+    return new MSQTaskQueryMaker(
+        ingestDestination,
+        fakeOverlordClient,
+        plannerContextMock,
+        objectMapper,
+        fieldMapping,
+        terminalStageSpecFactory
+    );
+  }
 }
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestBase.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestBase.java
index 1247a8e60cac..3d73e3f7f7e8 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestBase.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/MSQTestBase.java
@@ -574,7 +574,6 @@ public String getFormatString()
 
     final SqlEngine engine = new MSQTaskSqlEngine(
         indexingServiceClient,
-        NoopPolicyEnforcer.instance(),
         qf.queryJsonMapper().copy().registerModules(new MSQSqlModule().getJacksonModules()),
         new SegmentGenerationTerminalStageSpecFactory()
     );
diff --git a/processing/pom.xml b/processing/pom.xml
index 509dcbfa8f63..6c5b76ca1d72 100644
--- a/processing/pom.xml
+++ b/processing/pom.xml
@@ -387,7 +387,7 @@
     <dependency>
       <groupId>org.reflections</groupId>
       <artifactId>reflections</artifactId>
-      <scope>compile</scope>
+      <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>pl.pragmatists</groupId>
diff --git a/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java b/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java
index 454f9c9e92c1..d9a80d6f616b 100644
--- a/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java
+++ b/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java
@@ -180,7 +180,7 @@ public Optional<Closeable> acquireReferences()
   @Override
   public void validateOrElseThrow(PolicyEnforcer policyEnforcer)
   {
-    if (baseObject instanceof QueryableIndexSegment) {
+    if (baseObject instanceof QueryableIndexSegment || baseObject instanceof IncrementalIndexSegment) {
       policyEnforcer.validateOrElseThrow(this, null);
     }
   }
diff --git a/server/src/main/java/org/apache/druid/segment/InlineSegmentWrangler.java b/server/src/main/java/org/apache/druid/segment/InlineSegmentWrangler.java
index c1a3a5e425b9..6128dcf49f26 100644
--- a/server/src/main/java/org/apache/druid/segment/InlineSegmentWrangler.java
+++ b/server/src/main/java/org/apache/druid/segment/InlineSegmentWrangler.java
@@ -35,7 +35,7 @@
  */
 public class InlineSegmentWrangler implements SegmentWrangler
 {
-  public static final String SEGMENT_ID = "inline";
+  private static final String SEGMENT_ID = "inline";
 
   @Override
   @SuppressWarnings("unchecked")

From cb156c7ba7511b3257dd84b91fe4864771573cb3 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Fri, 11 Apr 2025 11:00:22 -0700
Subject: [PATCH 92/99] add test for stream appenderator

---
 .../druid/msq/sql/MSQTaskQueryMaker.java      |  1 -
 .../druid/msq/sql/MSQTaskSqlEngine.java       |  1 -
 .../druid/msq/exec/TestMSQSqlModule.java      |  1 -
 .../appenderator/StreamAppenderatorTest.java  | 52 +++++++++++++++++++
 4 files changed, 52 insertions(+), 3 deletions(-)

diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java
index 2e9c431959ed..0b777dae88ba 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java
@@ -55,7 +55,6 @@
 import org.apache.druid.query.QueryContext;
 import org.apache.druid.query.QueryContexts;
 import org.apache.druid.query.aggregation.AggregatorFactory;
-import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.rpc.indexing.OverlordClient;
 import org.apache.druid.segment.IndexSpec;
 import org.apache.druid.segment.column.ColumnType;
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskSqlEngine.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskSqlEngine.java
index 6a100f685b5c..31a2f5e5e643 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskSqlEngine.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskSqlEngine.java
@@ -49,7 +49,6 @@
 import org.apache.druid.msq.util.DimensionSchemaUtils;
 import org.apache.druid.msq.util.MultiStageQueryContext;
 import org.apache.druid.query.QueryContext;
-import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.rpc.indexing.OverlordClient;
 import org.apache.druid.segment.column.ColumnHolder;
 import org.apache.druid.segment.column.ColumnType;
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/TestMSQSqlModule.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/TestMSQSqlModule.java
index 0e44570b49db..b3e7494c11c7 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/TestMSQSqlModule.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/exec/TestMSQSqlModule.java
@@ -31,7 +31,6 @@
 import org.apache.druid.msq.test.MSQTestBase;
 import org.apache.druid.msq.test.MSQTestOverlordServiceClient;
 import org.apache.druid.msq.test.MSQTestTaskActionClient;
-import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.sql.SqlStatementFactory;
 import org.apache.druid.sql.SqlToolbox;
 import org.apache.druid.sql.avatica.DruidMeta;
diff --git a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTest.java b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTest.java
index 72a221e9040a..cdd0e85c9c5c 100644
--- a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTest.java
+++ b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorTest.java
@@ -29,6 +29,7 @@
 import org.apache.druid.data.input.Committer;
 import org.apache.druid.data.input.InputRow;
 import org.apache.druid.data.input.MapBasedInputRow;
+import org.apache.druid.error.DruidException;
 import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.Pair;
@@ -38,10 +39,14 @@
 import org.apache.druid.query.Druids;
 import org.apache.druid.query.Order;
 import org.apache.druid.query.QueryPlus;
+import org.apache.druid.query.RestrictedDataSource;
 import org.apache.druid.query.Result;
 import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.query.TableDataSource;
 import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
 import org.apache.druid.query.context.ResponseContext;
+import org.apache.druid.query.policy.NoRestrictionPolicy;
+import org.apache.druid.query.policy.RestrictAllTablesPolicyEnforcer;
 import org.apache.druid.query.scan.ScanQuery;
 import org.apache.druid.query.scan.ScanResultValue;
 import org.apache.druid.query.spec.MultipleSpecificSegmentSpec;
@@ -1859,6 +1864,53 @@ public void testQueryByIntervals_withSegmentVersionUpgrades() throws Exception
     }
   }
 
+  @Test
+  public void testQueryFailWithSecurityValidation() throws Exception
+  {
+    final StubServiceEmitter serviceEmitter = new StubServiceEmitter();
+    final StreamAppenderatorTester tester =
+        new StreamAppenderatorTester.Builder().maxRowsInMemory(2)
+                                              .basePersistDirectory(temporaryFolder.newFolder())
+                                              .withServiceEmitter(serviceEmitter)
+                                              .withPolicyEnforcer(new RestrictAllTablesPolicyEnforcer(null))
+                                              .build();
+    final Appenderator appenderator = tester.getAppenderator();
+
+    appenderator.startJob();
+    appenderator.add(IDENTIFIERS.get(0), ir("2000", "foo", 1), Suppliers.ofInstance(Committers.nil()));
+
+    // Query1: no policy restriction, fail
+    final TimeseriesQuery query1 = Druids.newTimeseriesQueryBuilder()
+                                         .dataSource(StreamAppenderatorTester.DATASOURCE)
+                                         .intervals(ImmutableList.of(Intervals.of("2000/2001")))
+                                         .aggregators(ImmutableList.of(new LongSumAggregatorFactory("count", "count")))
+                                         .granularity(Granularities.DAY)
+                                         .build();
+    DruidException e = Assert.assertThrows(
+        DruidException.class,
+        () -> QueryPlus.wrap(query1)
+                       .run(appenderator, ResponseContext.createEmpty())
+                       .toList()
+    );
+    Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
+    Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
+    Assert.assertEquals(
+        "Failed security validation with segment [foo_2000-01-01T00:00:00.000Z_2001-01-01T00:00:00.000Z_A]",
+        e.getMessage()
+    );
+
+    // Query2: with policy restriction, success
+    RestrictedDataSource restrictedDataSource = RestrictedDataSource.create(
+        TableDataSource.create(StreamAppenderatorTester.DATASOURCE), NoRestrictionPolicy.instance());
+    final TimeseriesQuery query2 = Druids.newTimeseriesQueryBuilder()
+                                         .dataSource(restrictedDataSource)
+                                         .intervals(ImmutableList.of(Intervals.of("2000/2001")))
+                                         .aggregators(ImmutableList.of(new LongSumAggregatorFactory("count", "count")))
+                                         .granularity(Granularities.DAY)
+                                         .build();
+    QueryPlus.wrap(query2).run(appenderator, ResponseContext.createEmpty()).toList();
+  }
+
   @Test
   public void testQueryByIntervals() throws Exception
   {

From 7380213c60cf6789f2713621ee9f5bbe929cf386 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Fri, 11 Apr 2025 13:16:36 -0700
Subject: [PATCH 93/99] update PolicyEnforcer to take ReferenceCountingSegment
 as param

---
 .../druid/query/policy/PolicyEnforcer.java    | 29 ++++++++++++-------
 .../segment/ReferenceCountingSegment.java     |  4 +--
 .../druid/segment/RestrictedSegment.java      | 13 +++++----
 .../druid/segment/SegmentReference.java       | 11 +++++--
 .../query/policy/NoopPolicyEnforcerTest.java  |  7 ++---
 .../RestrictAllTablesPolicyEnforcerTest.java  | 18 +++++-------
 6 files changed, 46 insertions(+), 36 deletions(-)

diff --git a/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java b/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
index 26d4bc4e1d28..29fcb231e6d3 100644
--- a/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
+++ b/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
@@ -25,6 +25,10 @@
 import org.apache.druid.guice.annotations.UnstableApi;
 import org.apache.druid.query.DataSource;
 import org.apache.druid.query.TableDataSource;
+import org.apache.druid.segment.IncrementalIndexSegment;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.SegmentReference;
 
 /**
@@ -49,7 +53,7 @@ public interface PolicyEnforcer
    * for each {@link TableDataSource} that is not wrapped inside a {@link org.apache.druid.query.RestrictedDataSource},
    * no matter where they appear within the tree.
    *
-   * @param ds     the data source to validate. Always {@link TableDataSource}.
+   * @param ds     the table to validate.
    * @param policy the policy attached to the table; either {@link org.apache.druid.query.RestrictedDataSource#policy} or null.
    * @throws DruidException if the data source does not comply with the policy
    */
@@ -64,9 +68,9 @@ default void validateOrElseThrow(TableDataSource ds, Policy policy) throws Druid
   }
 
   /**
-   * Validates a {@link SegmentReference} against the policy enforcer. This method is invoked during query execution via
-   * {@link SegmentReference#validateOrElseThrow(PolicyEnforcer)}. The callsite must ensure that the segment reference
-   * is not a deeply linked segment reference, and it must be referenced to a druid table.
+   * Validates a {@link SegmentReference} against the policy enforcer. Prior to query execution, the {@link SegmentReference} tree is walked.
+   * This method is invoked once for each {@link org.apache.druid.segment.RestrictedSegment} and once for each {@link ReferenceCountingSegment}
+   * that is not wrapped inside a {@link org.apache.druid.segment.RestrictedSegment}.
    * <p>
    * Direct invocation of this method is discouraged; use {@link SegmentReference#validateOrElseThrow(PolicyEnforcer)} instead.
    *
@@ -74,14 +78,19 @@ default void validateOrElseThrow(TableDataSource ds, Policy policy) throws Druid
    * @param policy  the policy on the segment, {@link org.apache.druid.segment.RestrictedSegment#policy} or null for other
    * @throws DruidException if the segment does not comply with the policy
    */
-  default void validateOrElseThrow(SegmentReference segment, Policy policy) throws DruidException
+  default void validateOrElseThrow(ReferenceCountingSegment segment, Policy policy) throws DruidException
   {
-    if (validate(policy)) {
-      return;
+    Segment baseSegment = segment.getBaseSegment();
+    if (baseSegment instanceof QueryableIndexSegment || baseSegment instanceof IncrementalIndexSegment) {
+      if (validate(policy)) {
+        return;
+      }
+      throw DruidException.forPersona(DruidException.Persona.OPERATOR)
+                          .ofCategory(DruidException.Category.FORBIDDEN)
+                          .build("Failed security validation with segment [%s]", segment.getId());
+    } else {
+      // not a druid table, skip validation
     }
-    throw DruidException.forPersona(DruidException.Persona.OPERATOR)
-                        .ofCategory(DruidException.Category.FORBIDDEN)
-                        .build("Failed security validation with segment [%s]", segment.getId());
   }
 
   /**
diff --git a/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java b/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java
index d9a80d6f616b..8957ec723d74 100644
--- a/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java
+++ b/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java
@@ -180,9 +180,7 @@ public Optional<Closeable> acquireReferences()
   @Override
   public void validateOrElseThrow(PolicyEnforcer policyEnforcer)
   {
-    if (baseObject instanceof QueryableIndexSegment || baseObject instanceof IncrementalIndexSegment) {
-      policyEnforcer.validateOrElseThrow(this, null);
-    }
+    policyEnforcer.validateOrElseThrow(this, null);
   }
 
   @Override
diff --git a/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java b/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java
index a8aa946ac932..f3f5563d7c36 100644
--- a/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java
+++ b/processing/src/main/java/org/apache/druid/segment/RestrictedSegment.java
@@ -19,6 +19,7 @@
 
 package org.apache.druid.segment;
 
+import com.google.common.base.Preconditions;
 import org.apache.druid.query.policy.NoRestrictionPolicy;
 import org.apache.druid.query.policy.Policy;
 import org.apache.druid.query.policy.PolicyEnforcer;
@@ -46,11 +47,13 @@ public class RestrictedSegment implements SegmentReference
   protected final SegmentReference delegate;
   protected final Policy policy;
 
-  public RestrictedSegment(
-      SegmentReference delegate,
-      Policy policy
-  )
+  public RestrictedSegment(SegmentReference delegate, Policy policy)
   {
+    // This is a sanity check, a restricted data source should alway wrap a druid table directly.
+    Preconditions.checkArgument(
+        delegate instanceof ReferenceCountingSegment,
+        "delegate must be a ReferenceCountingSegment"
+    );
     this.delegate = delegate;
     this.policy = policy;
   }
@@ -113,7 +116,7 @@ public <T> T as(@Nonnull Class<T> clazz)
   @Override
   public void validateOrElseThrow(PolicyEnforcer policyEnforcer)
   {
-    policyEnforcer.validateOrElseThrow(delegate, policy);
+    policyEnforcer.validateOrElseThrow((ReferenceCountingSegment) delegate, policy);
   }
 
   @Override
diff --git a/processing/src/main/java/org/apache/druid/segment/SegmentReference.java b/processing/src/main/java/org/apache/druid/segment/SegmentReference.java
index e65952f3e552..fba3e3158734 100644
--- a/processing/src/main/java/org/apache/druid/segment/SegmentReference.java
+++ b/processing/src/main/java/org/apache/druid/segment/SegmentReference.java
@@ -19,10 +19,11 @@
 
 package org.apache.druid.segment;
 
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.policy.PolicyEnforcer;
 
 /**
- * A {@link Segment} with a associated references, such as {@link ReferenceCountingSegment} where the reference is
+ * A {@link Segment} with an associated references, such as {@link ReferenceCountingSegment} where the reference is
  * the segment itself, and {@link org.apache.druid.segment.join.HashJoinSegment} which wraps a
  * {@link ReferenceCountingSegment} and also includes the associated list of
  * {@link org.apache.druid.segment.join.JoinableClause}
@@ -31,14 +32,18 @@ public interface SegmentReference extends Segment, ReferenceCountedObject
 {
 
   /**
-   * Returns true if the segment complies with the policy restrictions on tables.
+   * Validates if the segment complies with the policy restrictions on tables.
    * <p>
    * This should be called right before the segment is about to be processed by the query stack, and after
    * {@link org.apache.druid.query.planning.ExecutionVertex#createSegmentMapFunction(PolicyEnforcer)}.
    */
   default void validateOrElseThrow(PolicyEnforcer policyEnforcer)
   {
-    policyEnforcer.validateOrElseThrow(this, null);
+    // For testing purposes, we allow the NoopPolicyEnforcer to pass through.
+    if (policyEnforcer instanceof NoopPolicyEnforcer) {
+      return;
+    }
+    throw new UnsupportedOperationException("validateOrElseThrow is not supported");
   }
 
 }
diff --git a/processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java b/processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java
index 60e78c05e96e..8c19977440c0 100644
--- a/processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/policy/NoopPolicyEnforcerTest.java
@@ -25,9 +25,7 @@
 import org.apache.druid.query.TableDataSource;
 import org.apache.druid.query.filter.NullFilter;
 import org.apache.druid.segment.ReferenceCountingSegment;
-import org.apache.druid.segment.RestrictedSegment;
 import org.apache.druid.segment.Segment;
-import org.apache.druid.segment.SegmentReference;
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.segment.TestSegmentUtils;
 import org.junit.Assert;
@@ -71,12 +69,11 @@ public void test_validate() throws Exception
     policyEnforcer.validateOrElseThrow(restricted.getBase(), restricted.getPolicy());
 
     Segment baseSegment = new TestSegmentUtils.SegmentForTesting("table", Intervals.ETERNITY, "1");
-    SegmentReference segment = ReferenceCountingSegment.wrapRootGenerationSegment(baseSegment);
-    RestrictedSegment restrictedSegment = new RestrictedSegment(segment, policy);
+    ReferenceCountingSegment segment = ReferenceCountingSegment.wrapRootGenerationSegment(baseSegment);
     Assert.assertTrue(policyEnforcer.validate(null));
     Assert.assertTrue(policyEnforcer.validate(policy));
     policyEnforcer.validateOrElseThrow(segment, null);
-    policyEnforcer.validateOrElseThrow(restrictedSegment, policy);
+    policyEnforcer.validateOrElseThrow(segment, policy);
 
   }
 
diff --git a/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java b/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
index a578582dfa64..86c597d6e83c 100644
--- a/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
@@ -27,9 +27,7 @@
 import org.apache.druid.query.TableDataSource;
 import org.apache.druid.query.filter.NullFilter;
 import org.apache.druid.segment.ReferenceCountingSegment;
-import org.apache.druid.segment.RestrictedSegment;
 import org.apache.druid.segment.Segment;
-import org.apache.druid.segment.SegmentReference;
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.segment.TestSegmentUtils.SegmentForTesting;
 import org.junit.Assert;
@@ -40,7 +38,8 @@ public class RestrictAllTablesPolicyEnforcerTest
   @Test
   public void test_serialize() throws Exception
   {
-    RestrictAllTablesPolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(ImmutableList.of(NoRestrictionPolicy.class.getName()));
+    RestrictAllTablesPolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(ImmutableList.of(
+        NoRestrictionPolicy.class.getName()));
     ObjectMapper jsonMapper = TestHelper.makeJsonMapper();
 
     String expected = "{\"type\":\"restrictAllTables\",\"allowedPolicies\":[\"org.apache.druid.query.policy.NoRestrictionPolicy\"]}";
@@ -62,11 +61,11 @@ public void test_serde_roundTrip() throws Exception
   @Test
   public void test_validate() throws Exception
   {
-    RestrictAllTablesPolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    final RestrictAllTablesPolicyEnforcer policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
     RowFilterPolicy policy = RowFilterPolicy.from(new NullFilter("some-col", null));
     TableDataSource table = TableDataSource.create("table");
     RestrictedDataSource restricted = RestrictedDataSource.create(table, policy);
-
+    // Test validate data source, fail for TableDataSource, success for RestrictedDataSource
     Assert.assertFalse(policyEnforcer.validate(null));
     Assert.assertTrue(policyEnforcer.validate(policy));
     final DruidException e = Assert.assertThrows(
@@ -80,10 +79,9 @@ public void test_validate() throws Exception
         e.getMessage()
     );
     policyEnforcer.validateOrElseThrow(restricted.getBase(), restricted.getPolicy());
-
+    // Test validate segment, fail for ReferenceCountingSegment not wrapped with any policy, success when wrapped with a policy
     Segment baseSegment = new SegmentForTesting("table", Intervals.ETERNITY, "1");
-    SegmentReference segment = ReferenceCountingSegment.wrapRootGenerationSegment(baseSegment);
-    RestrictedSegment restrictedSegment = new RestrictedSegment(segment, policy);
+    ReferenceCountingSegment segment = ReferenceCountingSegment.wrapRootGenerationSegment(baseSegment);
     Assert.assertFalse(policyEnforcer.validate(null));
     Assert.assertTrue(policyEnforcer.validate(policy));
     final DruidException e2 = Assert.assertThrows(
@@ -96,7 +94,7 @@ public void test_validate() throws Exception
         "Failed security validation with segment [table_-146136543-09-08T08:23:32.096Z_146140482-04-24T15:36:27.903Z_1]",
         e2.getMessage()
     );
-    policyEnforcer.validateOrElseThrow(restrictedSegment, policy);
+    policyEnforcer.validateOrElseThrow(segment, policy);
   }
 
   @Test
@@ -116,7 +114,7 @@ public void test_validate_withAllowedPolicies() throws Exception
     policyEnforcer.validateOrElseThrow(table, NoRestrictionPolicy.instance());
 
     Segment baseSegment = new SegmentForTesting("table", Intervals.ETERNITY, "1");
-    SegmentReference segment = ReferenceCountingSegment.wrapRootGenerationSegment(baseSegment);
+    ReferenceCountingSegment segment = ReferenceCountingSegment.wrapRootGenerationSegment(baseSegment);
     Assert.assertThrows(DruidException.class, () -> policyEnforcer.validateOrElseThrow(segment, null));
     Assert.assertThrows(DruidException.class, () -> policyEnforcer.validateOrElseThrow(segment, policy));
     policyEnforcer.validateOrElseThrow(segment, NoRestrictionPolicy.instance());

From 5904a30498c1a253b8b7b94bac32fe202ba50368 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Fri, 11 Apr 2025 13:25:48 -0700
Subject: [PATCH 94/99] update to QueryLifecycleTest

---
 .../apache/druid/server/QueryLifecycleTest.java  | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/server/src/test/java/org/apache/druid/server/QueryLifecycleTest.java b/server/src/test/java/org/apache/druid/server/QueryLifecycleTest.java
index d202a60078c5..cd39030bd3a2 100644
--- a/server/src/test/java/org/apache/druid/server/QueryLifecycleTest.java
+++ b/server/src/test/java/org/apache/druid/server/QueryLifecycleTest.java
@@ -454,9 +454,14 @@ public void testAuthorized_withPolicyRestriction()
     EasyMock.expect(runner.run(EasyMock.anyObject(), EasyMock.anyObject())).andReturn(Sequences.empty()).anyTimes();
     replayAll();
 
+    policyEnforcer = new RestrictAllTablesPolicyEnforcer(ImmutableList.of(
+        NoRestrictionPolicy.class.getName(),
+        RowFilterPolicy.class.getName()
+    ));
     QueryLifecycle lifecycle = createLifecycle();
     lifecycle.initialize(query);
     Assert.assertTrue(lifecycle.authorize(authenticationResult).allowBasicAccess());
+    // Success, query has a RowFilterPolicy, and is allowed by PolicyEnforcer.
     lifecycle.execute();
   }
 
@@ -467,8 +472,6 @@ public void testAuthorized_withPolicyRestriction_failedSecurityValidation()
     Policy rowFilterPolicy = RowFilterPolicy.from(new NullFilter("some-column", null));
     Access access = Access.allowWithRestriction(rowFilterPolicy);
 
-    DataSource expectedDataSource = RestrictedDataSource.create(TableDataSource.create(DATASOURCE), rowFilterPolicy);
-
     final TimeseriesQuery query = Druids.newTimeseriesQueryBuilder()
                                         .dataSource(DATASOURCE)
                                         .intervals(ImmutableList.of(Intervals.ETERNITY))
@@ -481,19 +484,12 @@ public void testAuthorized_withPolicyRestriction_failedSecurityValidation()
             .andReturn(access).anyTimes();
     EasyMock.expect(conglomerate.getToolChest(EasyMock.anyObject()))
             .andReturn(toolChest).anyTimes();
-    // We're expecting the data source in the query to be transformed to a RestrictedDataSource, with policy.
-    // Any other DataSource would throw AssertionError.
-    EasyMock.expect(texasRanger.getQueryRunnerForIntervals(
-                queryMatchDataSource(expectedDataSource),
-                EasyMock.anyObject()
-            ))
-            .andReturn(runner).anyTimes();
-    EasyMock.expect(runner.run(EasyMock.anyObject(), EasyMock.anyObject())).andReturn(Sequences.empty()).anyTimes();
     replayAll();
 
     policyEnforcer = new RestrictAllTablesPolicyEnforcer(ImmutableList.of(NoRestrictionPolicy.class.getName()));
     QueryLifecycle lifecycle = createLifecycle();
     lifecycle.initialize(query);
+    // Fail, only NoRestrictionPolicy is allowed.
     DruidException e = Assert.assertThrows(DruidException.class, () -> lifecycle.authorize(authenticationResult));
     Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
     Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());

From ebd8756f85596edd893571bd99aa6164e19fdb33 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Fri, 11 Apr 2025 13:29:54 -0700
Subject: [PATCH 95/99] update to SqlTestFramework

---
 .../java/org/apache/druid/sql/calcite/util/SqlTestFramework.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
index 04d1d3b2948c..fb5101b78dbd 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
@@ -398,7 +398,6 @@ protected PlannerComponentSupplier buildPlannerComponentSupplier()
     @Override
     public void gatherProperties(Properties properties)
     {
-      properties.setProperty("druid.policy.enforcer.type", "none");
     }
 
     @Override

From b9299515810f1a2833d6f2f43e9e56b66384fbbe Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Thu, 17 Apr 2025 14:23:41 -0700
Subject: [PATCH 96/99] pass enforcer to BroadcastJoinSegmentMapFnProcessor and
 add test. PolicyEnforcer should also deal with multiple layer wrapped
 segments/

---
 .../BaseLeafFrameProcessorFactory.java        |   1 +
 .../BroadcastJoinSegmentMapFnProcessor.java   |  11 +-
 ...roadcastJoinSegmentMapFnProcessorTest.java |   4 +
 .../druid/msq/sql/MSQTaskQueryMakerTest.java  | 213 +++++++++++++++++-
 .../druid/query/policy/PolicyEnforcer.java    |  12 +
 .../RestrictAllTablesPolicyEnforcerTest.java  |  40 ++++
 6 files changed, 277 insertions(+), 4 deletions(-)

diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessorFactory.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessorFactory.java
index cb72f80396c9..ef53988c476b 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessorFactory.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BaseLeafFrameProcessorFactory.java
@@ -351,6 +351,7 @@ private FrameProcessor<Function<SegmentReference, SegmentReference>> makeSegment
     } else {
       return BroadcastJoinSegmentMapFnProcessor.create(
           query,
+          frameContext.policyEnforcer(),
           broadcastInputs,
           frameContext.memoryParameters().getBroadcastBufferMemory()
       );
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BroadcastJoinSegmentMapFnProcessor.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BroadcastJoinSegmentMapFnProcessor.java
index d3ce49d5f8e0..7c1a6083c6ab 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BroadcastJoinSegmentMapFnProcessor.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/querykit/BroadcastJoinSegmentMapFnProcessor.java
@@ -40,6 +40,8 @@
 import org.apache.druid.query.InlineDataSource;
 import org.apache.druid.query.JoinAlgorithm;
 import org.apache.druid.query.Query;
+import org.apache.druid.query.planning.ExecutionVertex;
+import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.segment.ColumnValueSelector;
 import org.apache.druid.segment.Cursor;
 import org.apache.druid.segment.SegmentReference;
@@ -64,6 +66,7 @@
 public class BroadcastJoinSegmentMapFnProcessor implements FrameProcessor<Function<SegmentReference, SegmentReference>>
 {
   private final Query<?> query;
+  private final PolicyEnforcer policyEnforcer;
   private final Int2IntMap inputNumberToProcessorChannelMap;
   private final List<ReadableFrameChannel> channels;
   private final List<FrameReader> channelReaders;
@@ -87,6 +90,7 @@ public class BroadcastJoinSegmentMapFnProcessor implements FrameProcessor<Functi
    */
   public BroadcastJoinSegmentMapFnProcessor(
       final Query<?> query,
+      final PolicyEnforcer policyEnforcer,
       final Int2IntMap inputNumberToProcessorChannelMap,
       final List<ReadableFrameChannel> channels,
       final List<FrameReader> channelReaders,
@@ -94,6 +98,7 @@ public BroadcastJoinSegmentMapFnProcessor(
   )
   {
     this.query = query;
+    this.policyEnforcer = policyEnforcer;
     this.inputNumberToProcessorChannelMap = inputNumberToProcessorChannelMap;
     this.channels = channels;
     this.channelReaders = channelReaders;
@@ -117,6 +122,7 @@ public BroadcastJoinSegmentMapFnProcessor(
    */
   public static BroadcastJoinSegmentMapFnProcessor create(
       final Query<?> query,
+      final PolicyEnforcer policyEnforcer,
       final Int2ObjectMap<ReadableInput> sideChannels,
       final long memoryReservedForBroadcastJoin
   )
@@ -134,6 +140,7 @@ public static BroadcastJoinSegmentMapFnProcessor create(
 
     return new BroadcastJoinSegmentMapFnProcessor(
         query,
+        policyEnforcer,
         inputNumberToProcessorChannelMap,
         inputChannels,
         channelReaders,
@@ -193,7 +200,8 @@ private void addFrame(final int channelNumber, final Frame frame)
 
   private Function<SegmentReference, SegmentReference> createSegmentMapFunction()
   {
-    return inlineChannelData(query.getDataSource()).createSegmentMapFunction(query);
+    DataSource transformed = inlineChannelData(query.getDataSource());
+    return ExecutionVertex.of(query.withDataSource(transformed)).createSegmentMapFunction(policyEnforcer);
   }
 
   DataSource inlineChannelData(final DataSource originalDataSource)
@@ -230,7 +238,6 @@ DataSource inlineChannelData(final DataSource originalDataSource)
    * broadcast tables.
    *
    * @param readableInputs all readable input channel numbers, including non-side-channels
-   *
    * @return whether side channels have been fully read
    */
   boolean buildBroadcastTablesIncrementally(final IntSet readableInputs)
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/BroadcastJoinSegmentMapFnProcessorTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/BroadcastJoinSegmentMapFnProcessorTest.java
index 2f3efa679cd8..41f12b8d8816 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/BroadcastJoinSegmentMapFnProcessorTest.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/querykit/BroadcastJoinSegmentMapFnProcessorTest.java
@@ -46,6 +46,7 @@
 import org.apache.druid.query.JoinDataSource;
 import org.apache.druid.query.Query;
 import org.apache.druid.query.QueryContext;
+import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.segment.CursorFactory;
 import org.apache.druid.segment.QueryableIndexCursorFactory;
 import org.apache.druid.segment.TestIndex;
@@ -129,6 +130,7 @@ public void testBuildTableAndInlineData() throws IOException
 
     final BroadcastJoinSegmentMapFnProcessor broadcastJoinReader = new BroadcastJoinSegmentMapFnProcessor(
         null /* Query; not used for the methods we're testing */,
+        NoopPolicyEnforcer.instance(),
         sideStageChannelNumberMap,
         channels,
         channelReaders,
@@ -220,6 +222,7 @@ public void testBuildTableMemoryLimit() throws IOException
 
     final BroadcastJoinSegmentMapFnProcessor broadcastJoinHelper = new BroadcastJoinSegmentMapFnProcessor(
         null /* Query; not used for the methods we're testing */,
+        NoopPolicyEnforcer.instance(),
         sideStageChannelNumberMap,
         channels,
         channelReaders,
@@ -271,6 +274,7 @@ public void testBuildTableMemoryLimitWithSortMergeConfigured() throws IOExceptio
     EasyMock.replay(mockQuery);
     final BroadcastJoinSegmentMapFnProcessor broadcastJoinHelper = new BroadcastJoinSegmentMapFnProcessor(
         mockQuery,
+        NoopPolicyEnforcer.instance(),
         sideStageChannelNumberMap,
         channels,
         channelReaders,
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
index 3f99a52e314b..9483006ede7e 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
@@ -40,8 +40,11 @@
 import org.apache.druid.guice.annotations.Json;
 import org.apache.druid.jackson.DefaultObjectMapper;
 import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.granularity.Granularities;
 import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.math.expr.ExprMacroTable;
 import org.apache.druid.msq.exec.DataServerQueryHandlerFactory;
 import org.apache.druid.msq.indexing.destination.MSQTerminalStageSpecFactory;
 import org.apache.druid.msq.indexing.destination.SegmentGenerationTerminalStageSpecFactory;
@@ -55,15 +58,23 @@
 import org.apache.druid.query.Druids;
 import org.apache.druid.query.ForwardingQueryProcessingPool;
 import org.apache.druid.query.InlineDataSource;
+import org.apache.druid.query.JoinDataSource;
 import org.apache.druid.query.LookupDataSource;
 import org.apache.druid.query.OrderBy;
 import org.apache.druid.query.Query;
 import org.apache.druid.query.QueryContext;
+import org.apache.druid.query.QueryDataSource;
 import org.apache.druid.query.QueryProcessingPool;
 import org.apache.druid.query.RestrictedDataSource;
 import org.apache.druid.query.TableDataSource;
 import org.apache.druid.query.UnnestDataSource;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
 import org.apache.druid.query.filter.EqualityFilter;
+import org.apache.druid.query.groupby.GroupByQuery;
+import org.apache.druid.query.groupby.GroupByQueryConfig;
+import org.apache.druid.query.groupby.GroupByQueryRunnerTest;
+import org.apache.druid.query.groupby.GroupingEngine;
+import org.apache.druid.query.groupby.TestGroupByBuffers;
 import org.apache.druid.query.policy.NoopPolicyEnforcer;
 import org.apache.druid.query.policy.PolicyEnforcer;
 import org.apache.druid.query.policy.RestrictAllTablesPolicyEnforcer;
@@ -75,6 +86,9 @@
 import org.apache.druid.segment.column.ColumnConfig;
 import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.column.RowSignature;
+import org.apache.druid.segment.join.JoinConditionAnalysis;
+import org.apache.druid.segment.join.JoinType;
+import org.apache.druid.segment.join.JoinableFactoryWrapper;
 import org.apache.druid.server.QueryResponse;
 import org.apache.druid.server.QueryStackTests;
 import org.apache.druid.server.SpecificSegmentsQuerySegmentWalker;
@@ -138,6 +152,10 @@ public class MSQTaskQueryMakerTest
   @Bind
   private QueryProcessingPool queryProcessingPool;
   @Bind
+  private GroupingEngine groupingEngine;
+  @Bind
+  private JoinableFactoryWrapper joinableFactoryWrapper;
+  @Bind
   @Nullable
   private DataServerQueryHandlerFactory dataServerQueryHandlerFactory;
   @Bind(lazy = true)
@@ -167,13 +185,20 @@ public void setUp() throws Exception
         anyBoolean()
     )).thenAnswer(invocation -> (Supplier<?>) () -> {
       SegmentId segmentId = (SegmentId) invocation.getArguments()[0];
-      return ReferenceCountingResourceHolder.fromCloseable(walker.getSegment(segmentId));
+      return new ReferenceCountingResourceHolder(walker.getSegment(segmentId), () -> {
+        // no-op closer, we don't want to close the segment
+      });
     });
 
     objectMapper = TestHelper.makeJsonMapper();
     jsonMapper = new DefaultObjectMapper();
     indexIO = new IndexIO(objectMapper, ColumnConfig.DEFAULT);
     queryProcessingPool = new ForwardingQueryProcessingPool(Execs.singleThreaded("Test-runner-processing-pool"));
+    groupingEngine = GroupByQueryRunnerTest.makeQueryRunnerFactory(
+        new GroupByQueryConfig(),
+        TestGroupByBuffers.createDefault()
+    ).getGroupingEngine();
+    joinableFactoryWrapper = CalciteTests.createJoinableFactoryWrapper();
     policyEnforcer = NoopPolicyEnforcer.instance();
     terminalStageSpecFactory = new SegmentGenerationTerminalStageSpecFactory();
     when(plannerContextMock.getLookupLoadingSpec()).thenReturn(LookupLoadingSpec.NONE);
@@ -269,7 +294,6 @@ public void testScanQueryFailWithPolicyValidation() throws Exception
                                                                             .get()
                                                                             .get(MSQTaskReport.REPORT_KEY)
                                                                             .getPayload();
-    // Assert
     Assert.assertTrue(payload.getStatus().getStatus().isFailure());
     MSQErrorReport errorReport = payload.getStatus().getErrorReport();
     Assert.assertTrue(errorReport.getFault().getErrorMessage().contains("Failed security validation with segment"));
@@ -436,6 +460,191 @@ public void testLookupDataSourcePassedPolicyValidation() throws Exception
     assertResultsEquals("select v from lookyloo", expectedResults, payload.getResults().getResults());
   }
 
+  @Test
+  public void testJoinFailWithPolicyValidationOnLeftChild() throws Exception
+  {
+    // Arrange
+    policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    RowSignature resultSignature = RowSignature.builder()
+                                               .add("dim1", ColumnType.STRING)
+                                               .add("j0.a0", ColumnType.LONG)
+                                               .build();
+    fieldMapping = buildFieldMapping(resultSignature);
+    RestrictedDataSource restrictedDataSource = RestrictedDataSource.create(
+        TableDataSource.create(CalciteTests.DATASOURCE1),
+        RowFilterPolicy.from(new EqualityFilter(
+            "dim1",
+            ColumnType.STRING,
+            "abc",
+            null
+        ))
+    );
+    QueryDataSource rightChild = new QueryDataSource(new GroupByQuery.Builder().setInterval(Intervals.ETERNITY)
+                                                                               .setDataSource(restrictedDataSource)
+                                                                               .addAggregator(new CountAggregatorFactory(
+                                                                                   "a0"))
+                                                                               .setGranularity(Granularities.ALL)
+                                                                               .build());
+    JoinDataSource joinDataSourceLeftChildNoRestriction = JoinDataSource.create(
+        TableDataSource.create(CalciteTests.DATASOURCE1),
+        rightChild,
+        "j0.",
+        JoinConditionAnalysis.forExpression(
+            "1",
+            "j0.",
+            ExprMacroTable.nil()
+        ),
+        JoinType.INNER,
+        null,
+        null,
+        null
+    );
+    Query queryLeftChildNoRestriction = new Druids.ScanQueryBuilder().resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
+                                                                     .eternityInterval()
+                                                                     .dataSource(joinDataSourceLeftChildNoRestriction)
+                                                                     .columns(resultSignature.getColumnNames())
+                                                                     .columnTypes(resultSignature.getColumnTypes())
+                                                                     .build();
+    DruidQuery druidQueryMock = buildDruidQueryMock(queryLeftChildNoRestriction, resultSignature);
+    // Act
+    msqTaskQueryMaker = getMSQTaskQueryMaker();
+    QueryResponse<Object[]> response = msqTaskQueryMaker.runQuery(druidQueryMock);
+    // Assert
+    String taskId = (String) Iterables.getOnlyElement(response.getResults().toList())[0];
+    MSQTaskReportPayload payload = (MSQTaskReportPayload) fakeOverlordClient.taskReportAsMap(taskId)
+                                                                            .get()
+                                                                            .get(MSQTaskReport.REPORT_KEY)
+                                                                            .getPayload();
+    Assert.assertTrue(payload.getStatus().getStatus().isFailure());
+    MSQErrorReport errorReport = payload.getStatus().getErrorReport();
+    Assert.assertTrue(errorReport.getFault().getErrorMessage().contains("Failed security validation with segment"));
+  }
+
+  @Test
+  public void testJoinFailWithPolicyValidationOnRightChild() throws Exception
+  {
+    // Arrange
+    policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    RowSignature resultSignature = RowSignature.builder()
+                                               .add("dim1", ColumnType.STRING)
+                                               .add("j0.a0", ColumnType.LONG)
+                                               .build();
+    fieldMapping = buildFieldMapping(resultSignature);
+    RestrictedDataSource restrictedDataSource = RestrictedDataSource.create(
+        TableDataSource.create(CalciteTests.DATASOURCE1),
+        RowFilterPolicy.from(new EqualityFilter(
+            "dim1",
+            ColumnType.STRING,
+            "abc",
+            null
+        ))
+    );
+    QueryDataSource rightChildNoRestriction = new QueryDataSource(new GroupByQuery.Builder().setInterval(Intervals.ETERNITY)
+                                                                                            .setDataSource(CalciteTests.DATASOURCE1)
+                                                                                            .addAggregator(new CountAggregatorFactory(
+                                                                                                "a0"))
+                                                                                            .setGranularity(
+                                                                                                Granularities.ALL)
+                                                                                            .build());
+    JoinDataSource joinDataSourceRightChildNoRestriction = JoinDataSource.create(
+        restrictedDataSource,
+        rightChildNoRestriction,
+        "j0.",
+        JoinConditionAnalysis.forExpression(
+            "1",
+            "j0.",
+            ExprMacroTable.nil()
+        ),
+        JoinType.INNER,
+        null,
+        null,
+        null
+    );
+    Query queryRightChildNoRestriction = new Druids.ScanQueryBuilder().resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
+                                                                      .eternityInterval()
+                                                                      .dataSource(joinDataSourceRightChildNoRestriction)
+                                                                      .columns(resultSignature.getColumnNames())
+                                                                      .columnTypes(resultSignature.getColumnTypes())
+                                                                      .build();
+    DruidQuery druidQueryMock = buildDruidQueryMock(queryRightChildNoRestriction, resultSignature);
+    // Act
+    msqTaskQueryMaker = getMSQTaskQueryMaker();
+    QueryResponse<Object[]> response = msqTaskQueryMaker.runQuery(druidQueryMock);
+    // Assert
+    String taskId = (String) Iterables.getOnlyElement(response.getResults().toList())[0];
+    MSQTaskReportPayload payload = (MSQTaskReportPayload) fakeOverlordClient.taskReportAsMap(taskId)
+                                                                            .get()
+                                                                            .get(MSQTaskReport.REPORT_KEY)
+                                                                            .getPayload();
+    Assert.assertTrue(payload.getStatus().getStatus().isFailure());
+    MSQErrorReport errorReport = payload.getStatus().getErrorReport();
+    Assert.assertTrue(errorReport.getFault().getErrorMessage().contains("Failed security validation with segment"));
+  }
+
+  @Test
+  public void testJoinPassedPolicyValidation() throws Exception
+  {
+    // Arrange
+    policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
+    RowSignature resultSignature = RowSignature.builder()
+                                               .add("dim1", ColumnType.STRING)
+                                               .add("j0.a0", ColumnType.LONG)
+                                               .build();
+    fieldMapping = buildFieldMapping(resultSignature);
+    RestrictedDataSource restrictedDataSource = RestrictedDataSource.create(
+        TableDataSource.create(CalciteTests.DATASOURCE1),
+        RowFilterPolicy.from(new EqualityFilter(
+            "dim1",
+            ColumnType.STRING,
+            "abc",
+            null
+        ))
+    );
+    QueryDataSource rightChild = new QueryDataSource(new GroupByQuery.Builder().setInterval(Intervals.ETERNITY)
+                                                                               .setDataSource(restrictedDataSource)
+                                                                               .addAggregator(new CountAggregatorFactory(
+                                                                                   "a0"))
+                                                                               .setGranularity(Granularities.ALL)
+                                                                               .build());
+    JoinDataSource joinDataSource = JoinDataSource.create(
+        restrictedDataSource,
+        rightChild,
+        "j0.",
+        JoinConditionAnalysis.forExpression(
+            "1",
+            "j0.",
+            ExprMacroTable.nil()
+        ),
+        JoinType.INNER,
+        null,
+        null,
+        null
+    );
+    Query query = new Druids.ScanQueryBuilder().resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
+                                               .eternityInterval()
+                                               .dataSource(joinDataSource)
+                                               .columns(resultSignature.getColumnNames())
+                                               .columnTypes(resultSignature.getColumnTypes())
+                                               .build();
+    DruidQuery druidQueryMock = buildDruidQueryMock(query, resultSignature);
+    // Act
+    msqTaskQueryMaker = getMSQTaskQueryMaker();
+    QueryResponse<Object[]> response = msqTaskQueryMaker.runQuery(druidQueryMock);
+    // Assert
+    String taskId = (String) Iterables.getOnlyElement(response.getResults().toList())[0];
+    MSQTaskReportPayload payload = (MSQTaskReportPayload) fakeOverlordClient.taskReportAsMap(taskId)
+                                                                            .get()
+                                                                            .get(MSQTaskReport.REPORT_KEY)
+                                                                            .getPayload();
+    Assert.assertTrue(payload.getStatus().getStatus().isSuccess());
+    ImmutableList<Object[]> expectedResults = ImmutableList.of(new Object[]{"abc", 1L});
+    assertResultsEquals(
+        "select dim1, q.c from foo, (select count(*) c from foo) q",
+        expectedResults,
+        payload.getResults().getResults()
+    );
+  }
+
   private static DruidQuery buildDruidQueryMock(Query query, RowSignature resultSignature)
   {
     DruidQuery druidQueryMock = Mockito.mock(DruidQuery.class);
diff --git a/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java b/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
index 29fcb231e6d3..a7ca7588d2a2 100644
--- a/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
+++ b/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
@@ -21,6 +21,7 @@
 
 import com.fasterxml.jackson.annotation.JsonSubTypes;
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import com.google.common.base.Preconditions;
 import org.apache.druid.error.DruidException;
 import org.apache.druid.guice.annotations.UnstableApi;
 import org.apache.druid.query.DataSource;
@@ -28,6 +29,7 @@
 import org.apache.druid.segment.IncrementalIndexSegment;
 import org.apache.druid.segment.QueryableIndexSegment;
 import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.RestrictedSegment;
 import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.SegmentReference;
 
@@ -81,6 +83,16 @@ default void validateOrElseThrow(TableDataSource ds, Policy policy) throws Druid
   default void validateOrElseThrow(ReferenceCountingSegment segment, Policy policy) throws DruidException
   {
     Segment baseSegment = segment.getBaseSegment();
+    if (baseSegment instanceof ReferenceCountingSegment) {
+      // the policy is carried on the base segment
+      validateOrElseThrow((ReferenceCountingSegment) baseSegment, policy);
+      return;
+    } else if (baseSegment instanceof RestrictedSegment) {
+      // note: the policy must be null, we can't accept a RestrictedSegment wrap with another RestrictedSegment
+      Preconditions.checkArgument(policy == null, "policy wrapped with another policy is not allowed");
+      ((RestrictedSegment) baseSegment).validateOrElseThrow(this);
+      return;
+    }
     if (baseSegment instanceof QueryableIndexSegment || baseSegment instanceof IncrementalIndexSegment) {
       if (validate(policy)) {
         return;
diff --git a/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java b/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
index 86c597d6e83c..43f83d01e147 100644
--- a/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
@@ -27,6 +27,7 @@
 import org.apache.druid.query.TableDataSource;
 import org.apache.druid.query.filter.NullFilter;
 import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.RestrictedSegment;
 import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.segment.TestSegmentUtils.SegmentForTesting;
@@ -95,6 +96,45 @@ public void test_validate() throws Exception
         e2.getMessage()
     );
     policyEnforcer.validateOrElseThrow(segment, policy);
+    // Test multiple layers of ReferenceCountingSegment, success:
+    //    Restrict
+    //        Ref
+    //           Ref_base
+    //        policy
+    ReferenceCountingSegment wrapSegment = ReferenceCountingSegment.wrapRootGenerationSegment(segment);
+    policyEnforcer.validateOrElseThrow(wrapSegment, policy);
+    // Test multiple layers of ReferenceCountingSegment, fail:
+    //    Ref
+    //        Ref
+    //            Ref_base
+    Exception e3 = Assert.assertThrows(
+        Exception.class,
+        () -> policyEnforcer.validateOrElseThrow(wrapSegment, null)
+    );
+    Assert.assertEquals(
+        "Failed security validation with segment [table_-146136543-09-08T08:23:32.096Z_146140482-04-24T15:36:27.903Z_1]",
+        e3.getMessage()
+    );
+    // Test multiple layers of ReferenceCountingSegment, success:
+    //    Ref
+    //        Restrict
+    //            Ref_base
+    //            policy
+    RestrictedSegment restrictedSegment = new RestrictedSegment(segment, policy);
+    ReferenceCountingSegment wrapRestrictedSegment = ReferenceCountingSegment.wrapRootGenerationSegment(
+        restrictedSegment);
+    policyEnforcer.validateOrElseThrow(wrapRestrictedSegment, null);
+    // Test multiple layers of ReferenceCountingSegment, fail:
+    //    Restrict
+    //        Restrict
+    //            Ref_base
+    //            policy
+    //        policy
+    Exception e4 = Assert.assertThrows(
+        Exception.class,
+        () -> policyEnforcer.validateOrElseThrow(wrapRestrictedSegment, policy)
+    );
+    Assert.assertEquals("policy wrapped with another policy is not allowed", e4.getMessage());
   }
 
   @Test

From 1e6632fcb779919f3fc54050ab9b44aba19d3265 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Wed, 23 Apr 2025 10:24:24 -0700
Subject: [PATCH 97/99] ReferenceCountingSegment is not allowed to wrap with a
 SegmentReference, and PolicyEnforcer now validates all segments, remove test
 cases for inline/lookup.

---
 .../druid/msq/sql/MSQTaskQueryMakerTest.java  | 72 -------------------
 .../druid/query/policy/PolicyEnforcer.java    | 30 ++------
 .../segment/ReferenceCountingSegment.java     |  5 ++
 .../RestrictAllTablesPolicyEnforcerTest.java  | 40 -----------
 4 files changed, 11 insertions(+), 136 deletions(-)

diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
index 9483006ede7e..ddb266889e8f 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/sql/MSQTaskQueryMakerTest.java
@@ -57,10 +57,7 @@
 import org.apache.druid.msq.test.MSQTestTaskActionClient;
 import org.apache.druid.query.Druids;
 import org.apache.druid.query.ForwardingQueryProcessingPool;
-import org.apache.druid.query.InlineDataSource;
 import org.apache.druid.query.JoinDataSource;
-import org.apache.druid.query.LookupDataSource;
-import org.apache.druid.query.OrderBy;
 import org.apache.druid.query.Query;
 import org.apache.druid.query.QueryContext;
 import org.apache.druid.query.QueryDataSource;
@@ -391,75 +388,6 @@ public void testUnnestOnRestrictedPassedPolicyValidation() throws Exception
     );
   }
 
-  @Test
-  public void testInlineDataSourcePassedPolicyValidation() throws Exception
-  {
-    // Arrange
-    policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
-    RowSignature resultSignature = RowSignature.builder()
-                                               .add("EXPR$0", ColumnType.LONG)
-                                               .build();
-    fieldMapping = buildFieldMapping(resultSignature);
-    InlineDataSource inlineDataSource = InlineDataSource.fromIterable(
-        ImmutableList.of(new Object[]{2L}),
-        resultSignature
-    );
-    Query query = new Druids.ScanQueryBuilder().resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
-                                               .dataSource(inlineDataSource)
-                                               .eternityInterval()
-                                               .columns(resultSignature.getColumnNames())
-                                               .columnTypes(resultSignature.getColumnTypes())
-                                               .build();
-    DruidQuery druidQueryMock = buildDruidQueryMock(query, resultSignature);
-    // Act
-    msqTaskQueryMaker = getMSQTaskQueryMaker();
-    QueryResponse<Object[]> response = msqTaskQueryMaker.runQuery(druidQueryMock);
-    // Assert
-    String taskId = (String) Iterables.getOnlyElement(response.getResults().toList())[0];
-    MSQTaskReportPayload payload = (MSQTaskReportPayload) fakeOverlordClient.taskReportAsMap(taskId)
-                                                                            .get()
-                                                                            .get(MSQTaskReport.REPORT_KEY)
-                                                                            .getPayload();
-    Assert.assertTrue(payload.getStatus().getStatus().isSuccess());
-    ImmutableList<Object[]> expectedResults = ImmutableList.of(new Object[]{2L});
-    assertResultsEquals("select 1 + 1", expectedResults, payload.getResults().getResults());
-  }
-
-  @Test
-  public void testLookupDataSourcePassedPolicyValidation() throws Exception
-  {
-    // Arrange
-    policyEnforcer = new RestrictAllTablesPolicyEnforcer(null);
-    final RowSignature resultSignature = RowSignature.builder().add("v", ColumnType.STRING).build();
-    fieldMapping = buildFieldMapping(resultSignature);
-    Query query = new Druids.ScanQueryBuilder().resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
-                                               .eternityInterval()
-                                               .dataSource(new LookupDataSource("lookyloo"))
-                                               .columns(resultSignature.getColumnNames())
-                                               .columnTypes(resultSignature.getColumnTypes())
-                                               .orderBy(ImmutableList.of(OrderBy.ascending("v")))
-                                               .build();
-    DruidQuery druidQueryMock = buildDruidQueryMock(query, resultSignature);
-    // Act
-    msqTaskQueryMaker = getMSQTaskQueryMaker();
-    QueryResponse<Object[]> response = msqTaskQueryMaker.runQuery(druidQueryMock);
-    // Assert
-    String taskId = (String) Iterables.getOnlyElement(response.getResults().toList())[0];
-    MSQTaskReportPayload payload = (MSQTaskReportPayload) fakeOverlordClient.taskReportAsMap(taskId)
-                                                                            .get()
-                                                                            .get(MSQTaskReport.REPORT_KEY)
-                                                                            .getPayload();
-    // Assert
-    Assert.assertTrue(payload.getStatus().getStatus().isSuccess());
-    ImmutableList<Object[]> expectedResults = ImmutableList.of(
-        new Object[]{"mysteryvalue"},
-        new Object[]{"x6"},
-        new Object[]{"xa"},
-        new Object[]{"xabc"}
-    );
-    assertResultsEquals("select v from lookyloo", expectedResults, payload.getResults().getResults());
-  }
-
   @Test
   public void testJoinFailWithPolicyValidationOnLeftChild() throws Exception
   {
diff --git a/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java b/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
index a7ca7588d2a2..4b34b96c23b1 100644
--- a/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
+++ b/processing/src/main/java/org/apache/druid/query/policy/PolicyEnforcer.java
@@ -21,16 +21,11 @@
 
 import com.fasterxml.jackson.annotation.JsonSubTypes;
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
-import com.google.common.base.Preconditions;
 import org.apache.druid.error.DruidException;
 import org.apache.druid.guice.annotations.UnstableApi;
 import org.apache.druid.query.DataSource;
 import org.apache.druid.query.TableDataSource;
-import org.apache.druid.segment.IncrementalIndexSegment;
-import org.apache.druid.segment.QueryableIndexSegment;
 import org.apache.druid.segment.ReferenceCountingSegment;
-import org.apache.druid.segment.RestrictedSegment;
-import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.SegmentReference;
 
 /**
@@ -82,27 +77,14 @@ default void validateOrElseThrow(TableDataSource ds, Policy policy) throws Druid
    */
   default void validateOrElseThrow(ReferenceCountingSegment segment, Policy policy) throws DruidException
   {
-    Segment baseSegment = segment.getBaseSegment();
-    if (baseSegment instanceof ReferenceCountingSegment) {
-      // the policy is carried on the base segment
-      validateOrElseThrow((ReferenceCountingSegment) baseSegment, policy);
-      return;
-    } else if (baseSegment instanceof RestrictedSegment) {
-      // note: the policy must be null, we can't accept a RestrictedSegment wrap with another RestrictedSegment
-      Preconditions.checkArgument(policy == null, "policy wrapped with another policy is not allowed");
-      ((RestrictedSegment) baseSegment).validateOrElseThrow(this);
+    // Validation will always fail on lookups, external, and inline segments, because they will not have policies applied (except for NoopPolicyEnforcer).
+    // This is a temporary solution since we don't have a perfect way to identify segments that are backed by a regular table yet.
+    if (validate(policy)) {
       return;
     }
-    if (baseSegment instanceof QueryableIndexSegment || baseSegment instanceof IncrementalIndexSegment) {
-      if (validate(policy)) {
-        return;
-      }
-      throw DruidException.forPersona(DruidException.Persona.OPERATOR)
-                          .ofCategory(DruidException.Category.FORBIDDEN)
-                          .build("Failed security validation with segment [%s]", segment.getId());
-    } else {
-      // not a druid table, skip validation
-    }
+    throw DruidException.forPersona(DruidException.Persona.OPERATOR)
+                        .ofCategory(DruidException.Category.FORBIDDEN)
+                        .build("Failed security validation with segment [%s]", segment.getId());
   }
 
   /**
diff --git a/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java b/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java
index 8957ec723d74..d20ac379a765 100644
--- a/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java
+++ b/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java
@@ -80,6 +80,11 @@ protected ReferenceCountingSegment(
   )
   {
     super(baseSegment);
+    if (baseSegment instanceof SegmentReference) {
+      throw new IllegalArgumentException(
+          "baseSegment cannot be a SegmentReference, it must be a Segment"
+      );
+    }
     this.startRootPartitionId = (short) startRootPartitionId;
     this.endRootPartitionId = (short) endRootPartitionId;
     this.minorVersion = minorVersion;
diff --git a/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java b/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
index 43f83d01e147..86c597d6e83c 100644
--- a/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/policy/RestrictAllTablesPolicyEnforcerTest.java
@@ -27,7 +27,6 @@
 import org.apache.druid.query.TableDataSource;
 import org.apache.druid.query.filter.NullFilter;
 import org.apache.druid.segment.ReferenceCountingSegment;
-import org.apache.druid.segment.RestrictedSegment;
 import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.segment.TestSegmentUtils.SegmentForTesting;
@@ -96,45 +95,6 @@ public void test_validate() throws Exception
         e2.getMessage()
     );
     policyEnforcer.validateOrElseThrow(segment, policy);
-    // Test multiple layers of ReferenceCountingSegment, success:
-    //    Restrict
-    //        Ref
-    //           Ref_base
-    //        policy
-    ReferenceCountingSegment wrapSegment = ReferenceCountingSegment.wrapRootGenerationSegment(segment);
-    policyEnforcer.validateOrElseThrow(wrapSegment, policy);
-    // Test multiple layers of ReferenceCountingSegment, fail:
-    //    Ref
-    //        Ref
-    //            Ref_base
-    Exception e3 = Assert.assertThrows(
-        Exception.class,
-        () -> policyEnforcer.validateOrElseThrow(wrapSegment, null)
-    );
-    Assert.assertEquals(
-        "Failed security validation with segment [table_-146136543-09-08T08:23:32.096Z_146140482-04-24T15:36:27.903Z_1]",
-        e3.getMessage()
-    );
-    // Test multiple layers of ReferenceCountingSegment, success:
-    //    Ref
-    //        Restrict
-    //            Ref_base
-    //            policy
-    RestrictedSegment restrictedSegment = new RestrictedSegment(segment, policy);
-    ReferenceCountingSegment wrapRestrictedSegment = ReferenceCountingSegment.wrapRootGenerationSegment(
-        restrictedSegment);
-    policyEnforcer.validateOrElseThrow(wrapRestrictedSegment, null);
-    // Test multiple layers of ReferenceCountingSegment, fail:
-    //    Restrict
-    //        Restrict
-    //            Ref_base
-    //            policy
-    //        policy
-    Exception e4 = Assert.assertThrows(
-        Exception.class,
-        () -> policyEnforcer.validateOrElseThrow(wrapRestrictedSegment, policy)
-    );
-    Assert.assertEquals("policy wrapped with another policy is not allowed", e4.getMessage());
   }
 
   @Test

From f604abffa9f34a7b7c520445a1cce14d92325088 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Wed, 23 Apr 2025 11:17:29 -0700
Subject: [PATCH 98/99] moving ReferenceCountingSegment to another pr

---
 .../org/apache/druid/segment/ReferenceCountingSegment.java   | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java b/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java
index d20ac379a765..8957ec723d74 100644
--- a/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java
+++ b/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java
@@ -80,11 +80,6 @@ protected ReferenceCountingSegment(
   )
   {
     super(baseSegment);
-    if (baseSegment instanceof SegmentReference) {
-      throw new IllegalArgumentException(
-          "baseSegment cannot be a SegmentReference, it must be a Segment"
-      );
-    }
     this.startRootPartitionId = (short) startRootPartitionId;
     this.endRootPartitionId = (short) endRootPartitionId;
     this.minorVersion = minorVersion;

From 22327d3a31f2020e811e4557ee516ba9657ff511 Mon Sep 17 00:00:00 2001
From: cecemei <cece.mei@imply.io>
Date: Wed, 23 Apr 2025 11:21:07 -0700
Subject: [PATCH 99/99] Revert "Merge remote-tracking branch 'cecemei/debug'
 into policy"

This reverts commit 25ffb7ca8e5228786c1da65bc000b7de596dcd95, reversing
changes made to 1e6632fcb779919f3fc54050ab9b44aba19d3265.
---
 .../_common/common.runtime.properties         |  58 ++++--------------
 .../micro-quickstart/_common/log4j2.xml       |   8 +--
 .../micro-quickstart/broker/jvm.config        |   1 -
 .../broker/runtime.properties                 |   2 +-
 .../coordinator-overlord/jvm.config           |   1 -
 .../micro-quickstart/historical/jvm.config    |   1 -
 .../historical/runtime.properties             |   4 +-
 .../micro-quickstart/indexer/jvm.config       |  10 ---
 .../micro-quickstart/indexer/main.config      |   1 -
 .../indexer/runtime.properties                |  24 --------
 .../micro-quickstart/middleManager/jvm.config |   1 -
 .../micro-quickstart/router/jvm.config        |   1 -
 .../single-server/micro-quickstart.conf       |   2 +-
 web-console/favicon.png                       | Bin 403 -> 1156 bytes
 .../datasources-view/datasources-view.tsx     |   1 -
 .../src/views/tasks-view/tasks-view.tsx       |   1 -
 web-console/unified-console.html              |   2 +-
 17 files changed, 22 insertions(+), 96 deletions(-)
 delete mode 100644 examples/conf/druid/single-server/micro-quickstart/indexer/jvm.config
 delete mode 100644 examples/conf/druid/single-server/micro-quickstart/indexer/main.config
 delete mode 100644 examples/conf/druid/single-server/micro-quickstart/indexer/runtime.properties

diff --git a/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties b/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties
index 53542e7643ff..1af96555aaca 100644
--- a/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties
+++ b/examples/conf/druid/single-server/micro-quickstart/_common/common.runtime.properties
@@ -24,44 +24,12 @@
 # If you specify `druid.extensions.loadList=[]`, Druid won't load any extension from file system.
 # If you don't specify `druid.extensions.loadList`, Druid will load all the extensions under root extension directory.
 # More info: https://druid.apache.org/docs/latest/operations/including-extensions.html
-druid.extensions.loadList=["druid-basic-security", "druid-s3-extensions","postgresql-metadata-storage", "druid-hdfs-storage", "druid-kafka-indexing-service", "druid-datasketches", "druid-multi-stage-query", "druid-parquet-extensions"]
+druid.extensions.loadList=["druid-hdfs-storage", "druid-kafka-indexing-service", "druid-datasketches", "druid-multi-stage-query", "druid-parquet-extensions"]
 
 # If you have a different version of Hadoop, place your Hadoop client jar files in your hadoop-dependencies directory
 # and uncomment the line below to point to your directory.
 #druid.extensions.hadoopDependenciesDir=/my/dir/hadoop-dependencies
 
-# poll every 60 min
-druid.auth.basic.common.pollingPeriod = 3600000
-
-# Druid basic security
-druid.auth.authenticatorChain=["MyBasicMetadataAuthenticator"]
-druid.auth.authenticator.MyBasicMetadataAuthenticator.type=basic
-
-# Default password for 'admin' user, should be changed for production.
-druid.auth.authenticator.MyBasicMetadataAuthenticator.initialAdminPassword=password1
-
-# Default password for internal 'druid_system' user, should be changed for production.
-druid.auth.authenticator.MyBasicMetadataAuthenticator.initialInternalClientPassword=password2
-
-# Uses the metadata store for storing users.
-# You can use the authentication API to create new users and grant permissions
-druid.auth.authenticator.MyBasicMetadataAuthenticator.credentialsValidator.type=metadata
-
-# If true and if the request credential doesn't exist in this credentials store,
-# the request will proceed to next Authenticator in the chain.
-druid.auth.authenticator.MyBasicMetadataAuthenticator.skipOnFailure=false
-
-druid.auth.authenticator.MyBasicMetadataAuthenticator.authorizerName=MyBasicMetadataAuthorizer
-
-# Escalator
-druid.escalator.type=basic
-druid.escalator.internalClientUsername=druid_system
-druid.escalator.internalClientPassword=password2
-druid.escalator.authorizerName=MyBasicMetadataAuthorizer
-
-druid.auth.authorizers=["MyBasicMetadataAuthorizer"]
-
-druid.auth.authorizer.MyBasicMetadataAuthorizer.type=basic
 
 #
 # Hostname
@@ -87,10 +55,10 @@ druid.zk.paths.base=/druid
 #
 
 # For Derby server on your Druid Coordinator (only viable in a cluster with a single Coordinator, no fail-over):
-# druid.metadata.storage.type=derby
-# druid.metadata.storage.connector.connectURI=jdbc:derby://localhost:1527/var/druid/metadata.db;create=true
-# druid.metadata.storage.connector.host=localhost
-# druid.metadata.storage.connector.port=1527
+druid.metadata.storage.type=derby
+druid.metadata.storage.connector.connectURI=jdbc:derby://localhost:1527/var/druid/metadata.db;create=true
+druid.metadata.storage.connector.host=localhost
+druid.metadata.storage.connector.port=1527
 
 # For MySQL (make sure to include the MySQL JDBC driver on the classpath):
 #druid.metadata.storage.type=mysql
@@ -99,10 +67,10 @@ druid.zk.paths.base=/druid
 #druid.metadata.storage.connector.password=...
 
 # For PostgreSQL:
-druid.metadata.storage.type=postgresql
-druid.metadata.storage.connector.connectURI=jdbc:postgresql://localhost:5432/druid
-druid.metadata.storage.connector.user=druid
-druid.metadata.storage.connector.password=druid
+#druid.metadata.storage.type=postgresql
+#druid.metadata.storage.connector.connectURI=jdbc:postgresql://db.example.com:5432/druid
+#druid.metadata.storage.connector.user=...
+#druid.metadata.storage.connector.password=...
 
 #
 # Deep storage
@@ -110,7 +78,7 @@ druid.metadata.storage.connector.password=druid
 
 # For local disk (only viable in a cluster if this is a network mount):
 druid.storage.type=local
-druid.storage.storageDirectory=/Users/cecemei/codespace/var/druid/segments
+druid.storage.storageDirectory=var/druid/segments
 
 # For HDFS:
 #druid.storage.type=hdfs
@@ -129,7 +97,7 @@ druid.storage.storageDirectory=/Users/cecemei/codespace/var/druid/segments
 
 # For local disk (only viable in a cluster if this is a network mount):
 druid.indexer.logs.type=file
-druid.indexer.logs.directory=/Users/cecemei/codespace/var/druid/indexing-logs
+druid.indexer.logs.directory=var/druid/indexing-logs
 
 # For HDFS:
 #druid.indexer.logs.type=hdfs
@@ -152,8 +120,8 @@ druid.selectors.coordinator.serviceName=druid/coordinator
 #
 
 druid.monitoring.monitors=["org.apache.druid.java.util.metrics.JvmMonitor", "org.apache.druid.server.metrics.ServiceStatusMonitor"]
-druid.emitter=logging
-druid.emitter.logging.logLevel=debug
+druid.emitter=noop
+druid.emitter.logging.logLevel=info
 
 # Storage type of double columns
 # ommiting this will lead to index double as float at the storage layer
diff --git a/examples/conf/druid/single-server/micro-quickstart/_common/log4j2.xml b/examples/conf/druid/single-server/micro-quickstart/_common/log4j2.xml
index 37d93eebe693..b9f456c43eef 100644
--- a/examples/conf/druid/single-server/micro-quickstart/_common/log4j2.xml
+++ b/examples/conf/druid/single-server/micro-quickstart/_common/log4j2.xml
@@ -53,20 +53,20 @@
     </Root>
 
     <!-- Set level="debug" to see stack traces for query errors -->
-    <Logger name="org.apache.druid.server.QueryResource" level="debug" additivity="false">
+    <Logger name="org.apache.druid.server.QueryResource" level="info" additivity="false">
       <Appender-ref ref="FileAppender"/>
     </Logger>
-    <Logger name="org.apache.druid.server.QueryLifecycle" level="debug" additivity="false">
+    <Logger name="org.apache.druid.server.QueryLifecycle" level="info" additivity="false">
       <Appender-ref ref="FileAppender"/>
     </Logger>
 
     <!-- Set level="debug" or "trace" to see more Coordinator details (segment balancing, load/drop rules, etc) -->
-    <Logger name="org.apache.druid.server.coordinator" level="debug" additivity="false">
+    <Logger name="org.apache.druid.server.coordinator" level="info" additivity="false">
       <Appender-ref ref="FileAppender"/>
     </Logger>
 
     <!-- Set level="debug" to see low-level details about segments and ingestion -->
-    <Logger name="org.apache.druid.segment" level="debug" additivity="false">
+    <Logger name="org.apache.druid.segment" level="info" additivity="false">
       <Appender-ref ref="FileAppender"/>
     </Logger>
 
diff --git a/examples/conf/druid/single-server/micro-quickstart/broker/jvm.config b/examples/conf/druid/single-server/micro-quickstart/broker/jvm.config
index 53f75be7a646..5d666f6db234 100644
--- a/examples/conf/druid/single-server/micro-quickstart/broker/jvm.config
+++ b/examples/conf/druid/single-server/micro-quickstart/broker/jvm.config
@@ -7,4 +7,3 @@
 -Dfile.encoding=UTF-8
 -Djava.io.tmpdir=var/tmp
 -Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager
--agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5001
diff --git a/examples/conf/druid/single-server/micro-quickstart/broker/runtime.properties b/examples/conf/druid/single-server/micro-quickstart/broker/runtime.properties
index a7c492bc4631..92b85f8bc754 100644
--- a/examples/conf/druid/single-server/micro-quickstart/broker/runtime.properties
+++ b/examples/conf/druid/single-server/micro-quickstart/broker/runtime.properties
@@ -30,7 +30,7 @@ druid.broker.http.maxQueuedBytes=5MiB
 # Processing threads and buffers
 druid.processing.buffer.sizeBytes=100MiB
 druid.processing.numMergeBuffers=2
-druid.processing.tmpDir=/Users/cecemei/codespace/var/druid/processing
+druid.processing.tmpDir=var/druid/processing
 
 # Query cache disabled -- push down caching and merging instead
 druid.broker.cache.useCache=false
diff --git a/examples/conf/druid/single-server/micro-quickstart/coordinator-overlord/jvm.config b/examples/conf/druid/single-server/micro-quickstart/coordinator-overlord/jvm.config
index 8cf32760f798..aae520d8325f 100644
--- a/examples/conf/druid/single-server/micro-quickstart/coordinator-overlord/jvm.config
+++ b/examples/conf/druid/single-server/micro-quickstart/coordinator-overlord/jvm.config
@@ -7,4 +7,3 @@
 -Djava.io.tmpdir=var/tmp
 -Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager
 -Dderby.stream.error.file=var/druid/derby.log
--agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5002
diff --git a/examples/conf/druid/single-server/micro-quickstart/historical/jvm.config b/examples/conf/druid/single-server/micro-quickstart/historical/jvm.config
index d13169a217b3..79edb06e2030 100644
--- a/examples/conf/druid/single-server/micro-quickstart/historical/jvm.config
+++ b/examples/conf/druid/single-server/micro-quickstart/historical/jvm.config
@@ -7,4 +7,3 @@
 -Dfile.encoding=UTF-8
 -Djava.io.tmpdir=var/tmp
 -Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager
--agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5003
diff --git a/examples/conf/druid/single-server/micro-quickstart/historical/runtime.properties b/examples/conf/druid/single-server/micro-quickstart/historical/runtime.properties
index aa16b2cc2d29..76eaa5d4b0cd 100644
--- a/examples/conf/druid/single-server/micro-quickstart/historical/runtime.properties
+++ b/examples/conf/druid/single-server/micro-quickstart/historical/runtime.properties
@@ -27,10 +27,10 @@ druid.server.http.numThreads=12
 druid.processing.buffer.sizeBytes=200MiB
 druid.processing.numMergeBuffers=2
 druid.processing.numThreads=2
-druid.processing.tmpDir=/Users/cecemei/codespace/var/druid/processing
+druid.processing.tmpDir=var/druid/processing
 
 # Segment storage
-druid.segmentCache.locations=[{"path":"/Users/cecemei/codespace/var/druid/segment-cache","maxSize":"300g"}]
+druid.segmentCache.locations=[{"path":"var/druid/segment-cache","maxSize":"300g"}]
 
 # Query cache
 druid.historical.cache.useCache=true
diff --git a/examples/conf/druid/single-server/micro-quickstart/indexer/jvm.config b/examples/conf/druid/single-server/micro-quickstart/indexer/jvm.config
deleted file mode 100644
index bd1d6021fb03..000000000000
--- a/examples/conf/druid/single-server/micro-quickstart/indexer/jvm.config
+++ /dev/null
@@ -1,10 +0,0 @@
--server
--Xms1g
--Xmx1g
--XX:MaxDirectMemorySize=1280m
--XX:+ExitOnOutOfMemoryError
--Duser.timezone=UTC
--Dfile.encoding=UTF-8
--Djava.io.tmpdir=var/tmp
--Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager
--agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5104
diff --git a/examples/conf/druid/single-server/micro-quickstart/indexer/main.config b/examples/conf/druid/single-server/micro-quickstart/indexer/main.config
deleted file mode 100644
index 5183399415cf..000000000000
--- a/examples/conf/druid/single-server/micro-quickstart/indexer/main.config
+++ /dev/null
@@ -1 +0,0 @@
-org.apache.druid.cli.Main server indexer
diff --git a/examples/conf/druid/single-server/micro-quickstart/indexer/runtime.properties b/examples/conf/druid/single-server/micro-quickstart/indexer/runtime.properties
deleted file mode 100644
index 6e95c055e11d..000000000000
--- a/examples/conf/druid/single-server/micro-quickstart/indexer/runtime.properties
+++ /dev/null
@@ -1,24 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-druid.service=druid/indexer
-druid.plaintextPort=8184
-
-# HTTP server threads
-druid.server.http.numThreads=12
diff --git a/examples/conf/druid/single-server/micro-quickstart/middleManager/jvm.config b/examples/conf/druid/single-server/micro-quickstart/middleManager/jvm.config
index a24e8037d8e7..8a650fb358c9 100644
--- a/examples/conf/druid/single-server/micro-quickstart/middleManager/jvm.config
+++ b/examples/conf/druid/single-server/micro-quickstart/middleManager/jvm.config
@@ -6,4 +6,3 @@
 -Dfile.encoding=UTF-8
 -Djava.io.tmpdir=var/tmp
 -Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager
--agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5004
diff --git a/examples/conf/druid/single-server/micro-quickstart/router/jvm.config b/examples/conf/druid/single-server/micro-quickstart/router/jvm.config
index 909f7dfe705a..b822f4601790 100644
--- a/examples/conf/druid/single-server/micro-quickstart/router/jvm.config
+++ b/examples/conf/druid/single-server/micro-quickstart/router/jvm.config
@@ -7,4 +7,3 @@
 -Dfile.encoding=UTF-8
 -Djava.io.tmpdir=var/tmp
 -Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager
--agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005
diff --git a/examples/conf/supervise/single-server/micro-quickstart.conf b/examples/conf/supervise/single-server/micro-quickstart.conf
index 69dff0f631cf..78d43a3fd812 100644
--- a/examples/conf/supervise/single-server/micro-quickstart.conf
+++ b/examples/conf/supervise/single-server/micro-quickstart.conf
@@ -8,4 +8,4 @@ coordinator-overlord bin/run-druid coordinator-overlord conf/druid/single-server
 broker bin/run-druid broker conf/druid/single-server/micro-quickstart
 router bin/run-druid router conf/druid/single-server/micro-quickstart
 historical bin/run-druid historical conf/druid/single-server/micro-quickstart
-!p90 indexer bin/run-druid indexer conf/druid/single-server/micro-quickstart
+!p90 middleManager bin/run-druid middleManager conf/druid/single-server/micro-quickstart
diff --git a/web-console/favicon.png b/web-console/favicon.png
index c449d4cc189cf2427c452e50446416539e596059..96b9aff6791eb0e7ac3eb34d904a86227f3ec350 100644
GIT binary patch
literal 1156
zcmV-~1bh35P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F800004XF*Lt006O%
z3;baP000C#Nkl<ZSP8{fU1(fI6#i!Ky}R4|EQMe#>9(dC8rw}1A8fR~NFi-$)rjbe
zR;1V$8;TDFpZq2Dhk_`ASSo@DRTM?jmEwbFwAeP-`cjD)4N00T)zSu%o85GO?(TTb
z?B3<xyEn<Y$<l${nKS3i`Ocg<bLL!uDqAcT3z}wr7a;qj#5P*iTKchutNarJe*hvL
ziD*M3BO_U6EZ4+x0&Q)v_4&N@3IQJ=;K*|F%qK%k`u|kZ^nuCAk$;z3v#0^>?fXKR
z%=n80dX&H$mr}AgPo&70cS4~%-xwSFF5@TXYXI-svU1<hg8Tgz)i5`#>&9b#-l#BO
z^X87OTuz=LkZ27+OD#zNf&GcZpT9eWTn3bOez6YVHfDl6vBT+!fX(4EFS&iScWy&)
zA7u>2vL`ir(AcQGO5+1IUB^C}&(BKJoEc&abp%D%TVvHk``XKN)t6{;K8eEg739wT
zjLat=L#9$b(jukndOIJ5I)c(Yukot6^^4{vXxm~4Ki7}u!80&=_qYWVB^!&F<bh&_
z%U!QF$@pk<O$AyvK-;<%;e*dY>%K?vQqLbj?x!DJa-6Ip5#u&39B%2AQXX<~S3t=5
zc@!qbksbURC={Ug+y`UlPUOCgLoO^hHHWfUoYOhCJ7?{&eb%#Gob~~mw)uWN0~97F
zkooKsvhmYMpF9DrvlGUHyAVEn1PjMr^DL8nfzrd`Vbn&7h6Z*14X?k2(34LoCFu`O
zs@~|`U7?h*MKszmN?zDf!L4CJw6q}fNFTySUr@(jKKd|3&_LwEB?!a7+ygz3$)rQG
z_=|4=KdY<K<jf4xUwp1~iQCt!US@MZ#(tTl7pJwH3B8<JY3+_SwX`rjrF!;&XrdcV
z0V$IeIYF`kTuiLItyu%Tb2}PdqSAqyb?z6{Yume3pC9{M^`5_f=oTmg7L9>wqTizw
zg&Q}J{-_vy!F>-YwsrAWuNc!;1I04RkM}?4(rL(R*O2?+d!!CNt=z43+>PMlPbfv1
zQfxT2GB$ZY#OW6FI~mTgod=wA)r_^SZZy63KA>sHQeNQvP}xLW=K|6+3+75wv1o2a
zU_%svO`8zhy%)xwy|gz0>%w{5eE01N>|!d`hSY1gabw2^l#UNqNcl|IF=2bgrYl4#
z>a$;ciJQmYgv`-Z^fV#FiRtOlehxzNl0INr)-%;S#~wXpQqo<Q<{Ul6Q?P!!gzV`-
z6sE3}`R;*8F(%KIOEU7p0D0kMw_trJ+Wj%wy}GaEM8u^t!4203(xr8{grz3S9$@O0
z7Nu+emq>;oICCVJUgbtQ1N)s7G3zfMfekh>F?yLxXQEg0IQYY4hxeO+G0Ro4Z2<SP
zv)7aB*7cm?>XqX3UYZIz`PGm4(@Y!>hwnNxK7M}AZ=EX!`~)~IZpp`~*O+>Jp8p4_
W+@I<z535W70000<MNUMnLSTZRrZ;8)

literal 403
zcmeAS@N?(olHy`uVBq!ia0vp^9w5xY3?!3`olAj~Yk*IPt9yaZ!xwMS(3xv@uit-q
z@%BTYc-Accl?PVMKX~WC^EbY8Zdp&cc~{RRW}@}QMQd+6ho8NE@50Rog;wcnfCjRc
z1o;IsB)k_;IKRK+&%yUVp>Lipjv*CsZ*T1GYc>#QedxgSnESi;z5jvX$s2nDrHqbW
zQqr$~{!H7gs8}w1?TWdZc6H1Mf7-C>`nxH7tNu*YVh_vxp18nx+BOM=cSml|>RYPh
zU}~MO#Ov}UZ6%+;<hCsWl5ICDjZ(f&uyt6{evP3}!DXjIu6@fdvF2Ne>suGZEs$$!
zTjBqrJL!byOy?gP|I6%Jc+6k%enNopTT_82te*r-TvHi64O#yDJEQRD#(%k4(+#(r
zkud46HfGUf(iJdqW4ypS_vaRn0-gmX$M-Fi-c)r$PGNDoPeY1BfRmBJi6sjg!e*LW
m>e1;;m#^vYGVP7sBEMby$p5aR3swR{fWgz%&t;ucLK6UzV!cNI

diff --git a/web-console/src/views/datasources-view/datasources-view.tsx b/web-console/src/views/datasources-view/datasources-view.tsx
index 14ef2e33368f..8ff4ec9f4239 100644
--- a/web-console/src/views/datasources-view/datasources-view.tsx
+++ b/web-console/src/views/datasources-view/datasources-view.tsx
@@ -671,7 +671,6 @@ GROUP BY 1, 2`;
   }
 
   private readonly refresh = (auto: boolean): void => {
-    if (1 > 0) return; // skip refresh
     if (auto && hasOverlayOpen()) return;
     this.datasourceQueryManager.rerunLastQuery(auto);
 
diff --git a/web-console/src/views/tasks-view/tasks-view.tsx b/web-console/src/views/tasks-view/tasks-view.tsx
index 10b133329372..5972f5ef7ead 100644
--- a/web-console/src/views/tasks-view/tasks-view.tsx
+++ b/web-console/src/views/tasks-view/tasks-view.tsx
@@ -633,7 +633,6 @@ ORDER BY
           <RefreshButton
             localStorageKey={LocalStorageKeys.TASKS_REFRESH_RATE}
             onRefresh={auto => {
-              if (1 > 0) return; // skip refresh
               if (auto && hasOverlayOpen()) return;
               this.taskQueryManager.rerunLastQuery(auto);
             }}
diff --git a/web-console/unified-console.html b/web-console/unified-console.html
index aa85d7d9ebb7..803bc90d3966 100644
--- a/web-console/unified-console.html
+++ b/web-console/unified-console.html
@@ -24,7 +24,7 @@
       name="viewport"
       content="width=device-width, user-scalable=no, initial-scale=1, maximum-scale=1, minimum-scale=1"
     />
-    <title>&#9889;Apache Druid</title>
+    <title>Apache Druid</title>
     <meta name="description" content="Apache Druid console" />
     <link rel="shortcut icon" href="favicon.png" />
     <style>